strongdm.models

    1# Copyright 2020 StrongDM Inc
    2#
    3# Licensed under the Apache License, Version 2.0 (the "License");
    4# you may not use this file except in compliance with the License.
    5# You may obtain a copy of the License at
    6#
    7#     http://www.apache.org/licenses/LICENSE-2.0
    8#
    9# Unless required by applicable law or agreed to in writing, software
   10# distributed under the License is distributed on an "AS IS" BASIS,
   11# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   12# See the License for the specific language governing permissions and
   13# limitations under the License.
   14#
   15
   16# This file was generated by protogen. DO NOT EDIT.
   17
   18import collections
   19
   20
   21class AKS:
   22    '''
   23
   24    '''
   25    __slots__ = [
   26        'bind_interface',
   27        'certificate_authority',
   28        'client_certificate',
   29        'client_key',
   30        'egress_filter',
   31        'healthcheck_namespace',
   32        'healthy',
   33        'hostname',
   34        'id',
   35        'name',
   36        'port',
   37        'port_override',
   38        'remote_identity_group_id',
   39        'remote_identity_healthcheck_username',
   40        'secret_store_id',
   41        'tags',
   42    ]
   43
   44    def __init__(
   45        self,
   46        bind_interface=None,
   47        certificate_authority=None,
   48        client_certificate=None,
   49        client_key=None,
   50        egress_filter=None,
   51        healthcheck_namespace=None,
   52        healthy=None,
   53        hostname=None,
   54        id=None,
   55        name=None,
   56        port=None,
   57        port_override=None,
   58        remote_identity_group_id=None,
   59        remote_identity_healthcheck_username=None,
   60        secret_store_id=None,
   61        tags=None,
   62    ):
   63        self.bind_interface = bind_interface if bind_interface is not None else ''
   64        '''
   65         Bind interface
   66        '''
   67        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
   68        '''
   69
   70        '''
   71        self.client_certificate = client_certificate if client_certificate is not None else ''
   72        '''
   73
   74        '''
   75        self.client_key = client_key if client_key is not None else ''
   76        '''
   77
   78        '''
   79        self.egress_filter = egress_filter if egress_filter is not None else ''
   80        '''
   81         A filter applied to the routing logic to pin datasource to nodes.
   82        '''
   83        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
   84        '''
   85         The path used to check the health of your connection.  Defaults to `default`.
   86        '''
   87        self.healthy = healthy if healthy is not None else False
   88        '''
   89         True if the datasource is reachable and the credentials are valid.
   90        '''
   91        self.hostname = hostname if hostname is not None else ''
   92        '''
   93
   94        '''
   95        self.id = id if id is not None else ''
   96        '''
   97         Unique identifier of the Resource.
   98        '''
   99        self.name = name if name is not None else ''
  100        '''
  101         Unique human-readable name of the Resource.
  102        '''
  103        self.port = port if port is not None else 0
  104        '''
  105
  106        '''
  107        self.port_override = port_override if port_override is not None else 0
  108        '''
  109
  110        '''
  111        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
  112        '''
  113
  114        '''
  115        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
  116        '''
  117
  118        '''
  119        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  120        '''
  121         ID of the secret store containing credentials for this resource, if any.
  122        '''
  123        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  124        '''
  125         Tags is a map of key, value pairs.
  126        '''
  127
  128    def __repr__(self):
  129        return '<sdm.AKS ' + \
  130            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  131            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
  132            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
  133            'client_key: ' + repr(self.client_key) + ' ' +\
  134            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  135            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  136            'healthy: ' + repr(self.healthy) + ' ' +\
  137            'hostname: ' + repr(self.hostname) + ' ' +\
  138            'id: ' + repr(self.id) + ' ' +\
  139            'name: ' + repr(self.name) + ' ' +\
  140            'port: ' + repr(self.port) + ' ' +\
  141            'port_override: ' + repr(self.port_override) + ' ' +\
  142            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
  143            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
  144            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  145            'tags: ' + repr(self.tags) + ' ' +\
  146            '>'
  147
  148    def to_dict(self):
  149        return {
  150            'bind_interface': self.bind_interface,
  151            'certificate_authority': self.certificate_authority,
  152            'client_certificate': self.client_certificate,
  153            'client_key': self.client_key,
  154            'egress_filter': self.egress_filter,
  155            'healthcheck_namespace': self.healthcheck_namespace,
  156            'healthy': self.healthy,
  157            'hostname': self.hostname,
  158            'id': self.id,
  159            'name': self.name,
  160            'port': self.port,
  161            'port_override': self.port_override,
  162            'remote_identity_group_id': self.remote_identity_group_id,
  163            'remote_identity_healthcheck_username':
  164            self.remote_identity_healthcheck_username,
  165            'secret_store_id': self.secret_store_id,
  166            'tags': self.tags,
  167        }
  168
  169    @classmethod
  170    def from_dict(cls, d):
  171        return cls(
  172            bind_interface=d.get('bind_interface'),
  173            certificate_authority=d.get('certificate_authority'),
  174            client_certificate=d.get('client_certificate'),
  175            client_key=d.get('client_key'),
  176            egress_filter=d.get('egress_filter'),
  177            healthcheck_namespace=d.get('healthcheck_namespace'),
  178            healthy=d.get('healthy'),
  179            hostname=d.get('hostname'),
  180            id=d.get('id'),
  181            name=d.get('name'),
  182            port=d.get('port'),
  183            port_override=d.get('port_override'),
  184            remote_identity_group_id=d.get('remote_identity_group_id'),
  185            remote_identity_healthcheck_username=d.get(
  186                'remote_identity_healthcheck_username'),
  187            secret_store_id=d.get('secret_store_id'),
  188            tags=d.get('tags'),
  189        )
  190
  191
  192class AKSBasicAuth:
  193    '''
  194
  195    '''
  196    __slots__ = [
  197        'bind_interface',
  198        'egress_filter',
  199        'healthcheck_namespace',
  200        'healthy',
  201        'hostname',
  202        'id',
  203        'name',
  204        'password',
  205        'port',
  206        'port_override',
  207        'secret_store_id',
  208        'tags',
  209        'username',
  210    ]
  211
  212    def __init__(
  213        self,
  214        bind_interface=None,
  215        egress_filter=None,
  216        healthcheck_namespace=None,
  217        healthy=None,
  218        hostname=None,
  219        id=None,
  220        name=None,
  221        password=None,
  222        port=None,
  223        port_override=None,
  224        secret_store_id=None,
  225        tags=None,
  226        username=None,
  227    ):
  228        self.bind_interface = bind_interface if bind_interface is not None else ''
  229        '''
  230         Bind interface
  231        '''
  232        self.egress_filter = egress_filter if egress_filter is not None else ''
  233        '''
  234         A filter applied to the routing logic to pin datasource to nodes.
  235        '''
  236        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  237        '''
  238         The path used to check the health of your connection.  Defaults to `default`.
  239        '''
  240        self.healthy = healthy if healthy is not None else False
  241        '''
  242         True if the datasource is reachable and the credentials are valid.
  243        '''
  244        self.hostname = hostname if hostname is not None else ''
  245        '''
  246
  247        '''
  248        self.id = id if id is not None else ''
  249        '''
  250         Unique identifier of the Resource.
  251        '''
  252        self.name = name if name is not None else ''
  253        '''
  254         Unique human-readable name of the Resource.
  255        '''
  256        self.password = password if password is not None else ''
  257        '''
  258
  259        '''
  260        self.port = port if port is not None else 0
  261        '''
  262
  263        '''
  264        self.port_override = port_override if port_override is not None else 0
  265        '''
  266
  267        '''
  268        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  269        '''
  270         ID of the secret store containing credentials for this resource, if any.
  271        '''
  272        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  273        '''
  274         Tags is a map of key, value pairs.
  275        '''
  276        self.username = username if username is not None else ''
  277        '''
  278
  279        '''
  280
  281    def __repr__(self):
  282        return '<sdm.AKSBasicAuth ' + \
  283            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  284            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  285            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  286            'healthy: ' + repr(self.healthy) + ' ' +\
  287            'hostname: ' + repr(self.hostname) + ' ' +\
  288            'id: ' + repr(self.id) + ' ' +\
  289            'name: ' + repr(self.name) + ' ' +\
  290            'password: ' + repr(self.password) + ' ' +\
  291            'port: ' + repr(self.port) + ' ' +\
  292            'port_override: ' + repr(self.port_override) + ' ' +\
  293            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  294            'tags: ' + repr(self.tags) + ' ' +\
  295            'username: ' + repr(self.username) + ' ' +\
  296            '>'
  297
  298    def to_dict(self):
  299        return {
  300            'bind_interface': self.bind_interface,
  301            'egress_filter': self.egress_filter,
  302            'healthcheck_namespace': self.healthcheck_namespace,
  303            'healthy': self.healthy,
  304            'hostname': self.hostname,
  305            'id': self.id,
  306            'name': self.name,
  307            'password': self.password,
  308            'port': self.port,
  309            'port_override': self.port_override,
  310            'secret_store_id': self.secret_store_id,
  311            'tags': self.tags,
  312            'username': self.username,
  313        }
  314
  315    @classmethod
  316    def from_dict(cls, d):
  317        return cls(
  318            bind_interface=d.get('bind_interface'),
  319            egress_filter=d.get('egress_filter'),
  320            healthcheck_namespace=d.get('healthcheck_namespace'),
  321            healthy=d.get('healthy'),
  322            hostname=d.get('hostname'),
  323            id=d.get('id'),
  324            name=d.get('name'),
  325            password=d.get('password'),
  326            port=d.get('port'),
  327            port_override=d.get('port_override'),
  328            secret_store_id=d.get('secret_store_id'),
  329            tags=d.get('tags'),
  330            username=d.get('username'),
  331        )
  332
  333
  334class AKSServiceAccount:
  335    '''
  336
  337    '''
  338    __slots__ = [
  339        'bind_interface',
  340        'egress_filter',
  341        'healthcheck_namespace',
  342        'healthy',
  343        'hostname',
  344        'id',
  345        'name',
  346        'port',
  347        'port_override',
  348        'remote_identity_group_id',
  349        'remote_identity_healthcheck_username',
  350        'secret_store_id',
  351        'tags',
  352        'token',
  353    ]
  354
  355    def __init__(
  356        self,
  357        bind_interface=None,
  358        egress_filter=None,
  359        healthcheck_namespace=None,
  360        healthy=None,
  361        hostname=None,
  362        id=None,
  363        name=None,
  364        port=None,
  365        port_override=None,
  366        remote_identity_group_id=None,
  367        remote_identity_healthcheck_username=None,
  368        secret_store_id=None,
  369        tags=None,
  370        token=None,
  371    ):
  372        self.bind_interface = bind_interface if bind_interface is not None else ''
  373        '''
  374         Bind interface
  375        '''
  376        self.egress_filter = egress_filter if egress_filter is not None else ''
  377        '''
  378         A filter applied to the routing logic to pin datasource to nodes.
  379        '''
  380        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  381        '''
  382         The path used to check the health of your connection.  Defaults to `default`.
  383        '''
  384        self.healthy = healthy if healthy is not None else False
  385        '''
  386         True if the datasource is reachable and the credentials are valid.
  387        '''
  388        self.hostname = hostname if hostname is not None else ''
  389        '''
  390
  391        '''
  392        self.id = id if id is not None else ''
  393        '''
  394         Unique identifier of the Resource.
  395        '''
  396        self.name = name if name is not None else ''
  397        '''
  398         Unique human-readable name of the Resource.
  399        '''
  400        self.port = port if port is not None else 0
  401        '''
  402
  403        '''
  404        self.port_override = port_override if port_override is not None else 0
  405        '''
  406
  407        '''
  408        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
  409        '''
  410
  411        '''
  412        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
  413        '''
  414
  415        '''
  416        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  417        '''
  418         ID of the secret store containing credentials for this resource, if any.
  419        '''
  420        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  421        '''
  422         Tags is a map of key, value pairs.
  423        '''
  424        self.token = token if token is not None else ''
  425        '''
  426
  427        '''
  428
  429    def __repr__(self):
  430        return '<sdm.AKSServiceAccount ' + \
  431            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  432            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  433            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  434            'healthy: ' + repr(self.healthy) + ' ' +\
  435            'hostname: ' + repr(self.hostname) + ' ' +\
  436            'id: ' + repr(self.id) + ' ' +\
  437            'name: ' + repr(self.name) + ' ' +\
  438            'port: ' + repr(self.port) + ' ' +\
  439            'port_override: ' + repr(self.port_override) + ' ' +\
  440            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
  441            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
  442            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  443            'tags: ' + repr(self.tags) + ' ' +\
  444            'token: ' + repr(self.token) + ' ' +\
  445            '>'
  446
  447    def to_dict(self):
  448        return {
  449            'bind_interface': self.bind_interface,
  450            'egress_filter': self.egress_filter,
  451            'healthcheck_namespace': self.healthcheck_namespace,
  452            'healthy': self.healthy,
  453            'hostname': self.hostname,
  454            'id': self.id,
  455            'name': self.name,
  456            'port': self.port,
  457            'port_override': self.port_override,
  458            'remote_identity_group_id': self.remote_identity_group_id,
  459            'remote_identity_healthcheck_username':
  460            self.remote_identity_healthcheck_username,
  461            'secret_store_id': self.secret_store_id,
  462            'tags': self.tags,
  463            'token': self.token,
  464        }
  465
  466    @classmethod
  467    def from_dict(cls, d):
  468        return cls(
  469            bind_interface=d.get('bind_interface'),
  470            egress_filter=d.get('egress_filter'),
  471            healthcheck_namespace=d.get('healthcheck_namespace'),
  472            healthy=d.get('healthy'),
  473            hostname=d.get('hostname'),
  474            id=d.get('id'),
  475            name=d.get('name'),
  476            port=d.get('port'),
  477            port_override=d.get('port_override'),
  478            remote_identity_group_id=d.get('remote_identity_group_id'),
  479            remote_identity_healthcheck_username=d.get(
  480                'remote_identity_healthcheck_username'),
  481            secret_store_id=d.get('secret_store_id'),
  482            tags=d.get('tags'),
  483            token=d.get('token'),
  484        )
  485
  486
  487class AKSServiceAccountUserImpersonation:
  488    '''
  489
  490    '''
  491    __slots__ = [
  492        'bind_interface',
  493        'egress_filter',
  494        'healthcheck_namespace',
  495        'healthy',
  496        'hostname',
  497        'id',
  498        'name',
  499        'port',
  500        'port_override',
  501        'secret_store_id',
  502        'tags',
  503        'token',
  504    ]
  505
  506    def __init__(
  507        self,
  508        bind_interface=None,
  509        egress_filter=None,
  510        healthcheck_namespace=None,
  511        healthy=None,
  512        hostname=None,
  513        id=None,
  514        name=None,
  515        port=None,
  516        port_override=None,
  517        secret_store_id=None,
  518        tags=None,
  519        token=None,
  520    ):
  521        self.bind_interface = bind_interface if bind_interface is not None else ''
  522        '''
  523         Bind interface
  524        '''
  525        self.egress_filter = egress_filter if egress_filter is not None else ''
  526        '''
  527         A filter applied to the routing logic to pin datasource to nodes.
  528        '''
  529        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  530        '''
  531         The path used to check the health of your connection.  Defaults to `default`.
  532        '''
  533        self.healthy = healthy if healthy is not None else False
  534        '''
  535         True if the datasource is reachable and the credentials are valid.
  536        '''
  537        self.hostname = hostname if hostname is not None else ''
  538        '''
  539
  540        '''
  541        self.id = id if id is not None else ''
  542        '''
  543         Unique identifier of the Resource.
  544        '''
  545        self.name = name if name is not None else ''
  546        '''
  547         Unique human-readable name of the Resource.
  548        '''
  549        self.port = port if port is not None else 0
  550        '''
  551
  552        '''
  553        self.port_override = port_override if port_override is not None else 0
  554        '''
  555
  556        '''
  557        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  558        '''
  559         ID of the secret store containing credentials for this resource, if any.
  560        '''
  561        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  562        '''
  563         Tags is a map of key, value pairs.
  564        '''
  565        self.token = token if token is not None else ''
  566        '''
  567
  568        '''
  569
  570    def __repr__(self):
  571        return '<sdm.AKSServiceAccountUserImpersonation ' + \
  572            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  573            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  574            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  575            'healthy: ' + repr(self.healthy) + ' ' +\
  576            'hostname: ' + repr(self.hostname) + ' ' +\
  577            'id: ' + repr(self.id) + ' ' +\
  578            'name: ' + repr(self.name) + ' ' +\
  579            'port: ' + repr(self.port) + ' ' +\
  580            'port_override: ' + repr(self.port_override) + ' ' +\
  581            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  582            'tags: ' + repr(self.tags) + ' ' +\
  583            'token: ' + repr(self.token) + ' ' +\
  584            '>'
  585
  586    def to_dict(self):
  587        return {
  588            'bind_interface': self.bind_interface,
  589            'egress_filter': self.egress_filter,
  590            'healthcheck_namespace': self.healthcheck_namespace,
  591            'healthy': self.healthy,
  592            'hostname': self.hostname,
  593            'id': self.id,
  594            'name': self.name,
  595            'port': self.port,
  596            'port_override': self.port_override,
  597            'secret_store_id': self.secret_store_id,
  598            'tags': self.tags,
  599            'token': self.token,
  600        }
  601
  602    @classmethod
  603    def from_dict(cls, d):
  604        return cls(
  605            bind_interface=d.get('bind_interface'),
  606            egress_filter=d.get('egress_filter'),
  607            healthcheck_namespace=d.get('healthcheck_namespace'),
  608            healthy=d.get('healthy'),
  609            hostname=d.get('hostname'),
  610            id=d.get('id'),
  611            name=d.get('name'),
  612            port=d.get('port'),
  613            port_override=d.get('port_override'),
  614            secret_store_id=d.get('secret_store_id'),
  615            tags=d.get('tags'),
  616            token=d.get('token'),
  617        )
  618
  619
  620class AKSUserImpersonation:
  621    '''
  622
  623    '''
  624    __slots__ = [
  625        'bind_interface',
  626        'certificate_authority',
  627        'client_certificate',
  628        'client_key',
  629        'egress_filter',
  630        'healthcheck_namespace',
  631        'healthy',
  632        'hostname',
  633        'id',
  634        'name',
  635        'port',
  636        'port_override',
  637        'secret_store_id',
  638        'tags',
  639    ]
  640
  641    def __init__(
  642        self,
  643        bind_interface=None,
  644        certificate_authority=None,
  645        client_certificate=None,
  646        client_key=None,
  647        egress_filter=None,
  648        healthcheck_namespace=None,
  649        healthy=None,
  650        hostname=None,
  651        id=None,
  652        name=None,
  653        port=None,
  654        port_override=None,
  655        secret_store_id=None,
  656        tags=None,
  657    ):
  658        self.bind_interface = bind_interface if bind_interface is not None else ''
  659        '''
  660         Bind interface
  661        '''
  662        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
  663        '''
  664
  665        '''
  666        self.client_certificate = client_certificate if client_certificate is not None else ''
  667        '''
  668
  669        '''
  670        self.client_key = client_key if client_key is not None else ''
  671        '''
  672
  673        '''
  674        self.egress_filter = egress_filter if egress_filter is not None else ''
  675        '''
  676         A filter applied to the routing logic to pin datasource to nodes.
  677        '''
  678        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  679        '''
  680         The path used to check the health of your connection.  Defaults to `default`.
  681        '''
  682        self.healthy = healthy if healthy is not None else False
  683        '''
  684         True if the datasource is reachable and the credentials are valid.
  685        '''
  686        self.hostname = hostname if hostname is not None else ''
  687        '''
  688
  689        '''
  690        self.id = id if id is not None else ''
  691        '''
  692         Unique identifier of the Resource.
  693        '''
  694        self.name = name if name is not None else ''
  695        '''
  696         Unique human-readable name of the Resource.
  697        '''
  698        self.port = port if port is not None else 0
  699        '''
  700
  701        '''
  702        self.port_override = port_override if port_override is not None else 0
  703        '''
  704
  705        '''
  706        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  707        '''
  708         ID of the secret store containing credentials for this resource, if any.
  709        '''
  710        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  711        '''
  712         Tags is a map of key, value pairs.
  713        '''
  714
  715    def __repr__(self):
  716        return '<sdm.AKSUserImpersonation ' + \
  717            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  718            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
  719            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
  720            'client_key: ' + repr(self.client_key) + ' ' +\
  721            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  722            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  723            'healthy: ' + repr(self.healthy) + ' ' +\
  724            'hostname: ' + repr(self.hostname) + ' ' +\
  725            'id: ' + repr(self.id) + ' ' +\
  726            'name: ' + repr(self.name) + ' ' +\
  727            'port: ' + repr(self.port) + ' ' +\
  728            'port_override: ' + repr(self.port_override) + ' ' +\
  729            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  730            'tags: ' + repr(self.tags) + ' ' +\
  731            '>'
  732
  733    def to_dict(self):
  734        return {
  735            'bind_interface': self.bind_interface,
  736            'certificate_authority': self.certificate_authority,
  737            'client_certificate': self.client_certificate,
  738            'client_key': self.client_key,
  739            'egress_filter': self.egress_filter,
  740            'healthcheck_namespace': self.healthcheck_namespace,
  741            'healthy': self.healthy,
  742            'hostname': self.hostname,
  743            'id': self.id,
  744            'name': self.name,
  745            'port': self.port,
  746            'port_override': self.port_override,
  747            'secret_store_id': self.secret_store_id,
  748            'tags': self.tags,
  749        }
  750
  751    @classmethod
  752    def from_dict(cls, d):
  753        return cls(
  754            bind_interface=d.get('bind_interface'),
  755            certificate_authority=d.get('certificate_authority'),
  756            client_certificate=d.get('client_certificate'),
  757            client_key=d.get('client_key'),
  758            egress_filter=d.get('egress_filter'),
  759            healthcheck_namespace=d.get('healthcheck_namespace'),
  760            healthy=d.get('healthy'),
  761            hostname=d.get('hostname'),
  762            id=d.get('id'),
  763            name=d.get('name'),
  764            port=d.get('port'),
  765            port_override=d.get('port_override'),
  766            secret_store_id=d.get('secret_store_id'),
  767            tags=d.get('tags'),
  768        )
  769
  770
  771class AWS:
  772    '''
  773
  774    '''
  775    __slots__ = [
  776        'access_key',
  777        'bind_interface',
  778        'egress_filter',
  779        'healthcheck_region',
  780        'healthy',
  781        'id',
  782        'name',
  783        'role_arn',
  784        'role_external_id',
  785        'secret_access_key',
  786        'secret_store_id',
  787        'tags',
  788    ]
  789
  790    def __init__(
  791        self,
  792        access_key=None,
  793        bind_interface=None,
  794        egress_filter=None,
  795        healthcheck_region=None,
  796        healthy=None,
  797        id=None,
  798        name=None,
  799        role_arn=None,
  800        role_external_id=None,
  801        secret_access_key=None,
  802        secret_store_id=None,
  803        tags=None,
  804    ):
  805        self.access_key = access_key if access_key is not None else ''
  806        '''
  807
  808        '''
  809        self.bind_interface = bind_interface if bind_interface is not None else ''
  810        '''
  811         Bind interface
  812        '''
  813        self.egress_filter = egress_filter if egress_filter is not None else ''
  814        '''
  815         A filter applied to the routing logic to pin datasource to nodes.
  816        '''
  817        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
  818        '''
  819
  820        '''
  821        self.healthy = healthy if healthy is not None else False
  822        '''
  823         True if the datasource is reachable and the credentials are valid.
  824        '''
  825        self.id = id if id is not None else ''
  826        '''
  827         Unique identifier of the Resource.
  828        '''
  829        self.name = name if name is not None else ''
  830        '''
  831         Unique human-readable name of the Resource.
  832        '''
  833        self.role_arn = role_arn if role_arn is not None else ''
  834        '''
  835
  836        '''
  837        self.role_external_id = role_external_id if role_external_id is not None else ''
  838        '''
  839
  840        '''
  841        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
  842        '''
  843
  844        '''
  845        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  846        '''
  847         ID of the secret store containing credentials for this resource, if any.
  848        '''
  849        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  850        '''
  851         Tags is a map of key, value pairs.
  852        '''
  853
  854    def __repr__(self):
  855        return '<sdm.AWS ' + \
  856            'access_key: ' + repr(self.access_key) + ' ' +\
  857            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  858            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  859            'healthcheck_region: ' + repr(self.healthcheck_region) + ' ' +\
  860            'healthy: ' + repr(self.healthy) + ' ' +\
  861            'id: ' + repr(self.id) + ' ' +\
  862            'name: ' + repr(self.name) + ' ' +\
  863            'role_arn: ' + repr(self.role_arn) + ' ' +\
  864            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
  865            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
  866            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  867            'tags: ' + repr(self.tags) + ' ' +\
  868            '>'
  869
  870    def to_dict(self):
  871        return {
  872            'access_key': self.access_key,
  873            'bind_interface': self.bind_interface,
  874            'egress_filter': self.egress_filter,
  875            'healthcheck_region': self.healthcheck_region,
  876            'healthy': self.healthy,
  877            'id': self.id,
  878            'name': self.name,
  879            'role_arn': self.role_arn,
  880            'role_external_id': self.role_external_id,
  881            'secret_access_key': self.secret_access_key,
  882            'secret_store_id': self.secret_store_id,
  883            'tags': self.tags,
  884        }
  885
  886    @classmethod
  887    def from_dict(cls, d):
  888        return cls(
  889            access_key=d.get('access_key'),
  890            bind_interface=d.get('bind_interface'),
  891            egress_filter=d.get('egress_filter'),
  892            healthcheck_region=d.get('healthcheck_region'),
  893            healthy=d.get('healthy'),
  894            id=d.get('id'),
  895            name=d.get('name'),
  896            role_arn=d.get('role_arn'),
  897            role_external_id=d.get('role_external_id'),
  898            secret_access_key=d.get('secret_access_key'),
  899            secret_store_id=d.get('secret_store_id'),
  900            tags=d.get('tags'),
  901        )
  902
  903
  904class AWSStore:
  905    '''
  906
  907    '''
  908    __slots__ = [
  909        'id',
  910        'name',
  911        'region',
  912        'tags',
  913    ]
  914
  915    def __init__(
  916        self,
  917        id=None,
  918        name=None,
  919        region=None,
  920        tags=None,
  921    ):
  922        self.id = id if id is not None else ''
  923        '''
  924         Unique identifier of the SecretStore.
  925        '''
  926        self.name = name if name is not None else ''
  927        '''
  928         Unique human-readable name of the SecretStore.
  929        '''
  930        self.region = region if region is not None else ''
  931        '''
  932
  933        '''
  934        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  935        '''
  936         Tags is a map of key, value pairs.
  937        '''
  938
  939    def __repr__(self):
  940        return '<sdm.AWSStore ' + \
  941            'id: ' + repr(self.id) + ' ' +\
  942            'name: ' + repr(self.name) + ' ' +\
  943            'region: ' + repr(self.region) + ' ' +\
  944            'tags: ' + repr(self.tags) + ' ' +\
  945            '>'
  946
  947    def to_dict(self):
  948        return {
  949            'id': self.id,
  950            'name': self.name,
  951            'region': self.region,
  952            'tags': self.tags,
  953        }
  954
  955    @classmethod
  956    def from_dict(cls, d):
  957        return cls(
  958            id=d.get('id'),
  959            name=d.get('name'),
  960            region=d.get('region'),
  961            tags=d.get('tags'),
  962        )
  963
  964
  965class AccountAttachment:
  966    '''
  967     AccountAttachments assign an account to a role.
  968    '''
  969    __slots__ = [
  970        'account_id',
  971        'id',
  972        'role_id',
  973    ]
  974
  975    def __init__(
  976        self,
  977        account_id=None,
  978        id=None,
  979        role_id=None,
  980    ):
  981        self.account_id = account_id if account_id is not None else ''
  982        '''
  983         The id of the account of this AccountAttachment.
  984        '''
  985        self.id = id if id is not None else ''
  986        '''
  987         Unique identifier of the AccountAttachment.
  988        '''
  989        self.role_id = role_id if role_id is not None else ''
  990        '''
  991         The id of the attached role of this AccountAttachment.
  992        '''
  993
  994    def __repr__(self):
  995        return '<sdm.AccountAttachment ' + \
  996            'account_id: ' + repr(self.account_id) + ' ' +\
  997            'id: ' + repr(self.id) + ' ' +\
  998            'role_id: ' + repr(self.role_id) + ' ' +\
  999            '>'
 1000
 1001    def to_dict(self):
 1002        return {
 1003            'account_id': self.account_id,
 1004            'id': self.id,
 1005            'role_id': self.role_id,
 1006        }
 1007
 1008    @classmethod
 1009    def from_dict(cls, d):
 1010        return cls(
 1011            account_id=d.get('account_id'),
 1012            id=d.get('id'),
 1013            role_id=d.get('role_id'),
 1014        )
 1015
 1016
 1017class AccountAttachmentCreateResponse:
 1018    '''
 1019     AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.
 1020    '''
 1021    __slots__ = [
 1022        'account_attachment',
 1023        'meta',
 1024        'rate_limit',
 1025    ]
 1026
 1027    def __init__(
 1028        self,
 1029        account_attachment=None,
 1030        meta=None,
 1031        rate_limit=None,
 1032    ):
 1033        self.account_attachment = account_attachment if account_attachment is not None else None
 1034        '''
 1035         The created AccountAttachment.
 1036        '''
 1037        self.meta = meta if meta is not None else None
 1038        '''
 1039         Reserved for future use.
 1040        '''
 1041        self.rate_limit = rate_limit if rate_limit is not None else None
 1042        '''
 1043         Rate limit information.
 1044        '''
 1045
 1046    def __repr__(self):
 1047        return '<sdm.AccountAttachmentCreateResponse ' + \
 1048            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
 1049            'meta: ' + repr(self.meta) + ' ' +\
 1050            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1051            '>'
 1052
 1053    def to_dict(self):
 1054        return {
 1055            'account_attachment': self.account_attachment,
 1056            'meta': self.meta,
 1057            'rate_limit': self.rate_limit,
 1058        }
 1059
 1060    @classmethod
 1061    def from_dict(cls, d):
 1062        return cls(
 1063            account_attachment=d.get('account_attachment'),
 1064            meta=d.get('meta'),
 1065            rate_limit=d.get('rate_limit'),
 1066        )
 1067
 1068
 1069class AccountAttachmentDeleteResponse:
 1070    '''
 1071     AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.
 1072    '''
 1073    __slots__ = [
 1074        'meta',
 1075        'rate_limit',
 1076    ]
 1077
 1078    def __init__(
 1079        self,
 1080        meta=None,
 1081        rate_limit=None,
 1082    ):
 1083        self.meta = meta if meta is not None else None
 1084        '''
 1085         Reserved for future use.
 1086        '''
 1087        self.rate_limit = rate_limit if rate_limit is not None else None
 1088        '''
 1089         Rate limit information.
 1090        '''
 1091
 1092    def __repr__(self):
 1093        return '<sdm.AccountAttachmentDeleteResponse ' + \
 1094            'meta: ' + repr(self.meta) + ' ' +\
 1095            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1096            '>'
 1097
 1098    def to_dict(self):
 1099        return {
 1100            'meta': self.meta,
 1101            'rate_limit': self.rate_limit,
 1102        }
 1103
 1104    @classmethod
 1105    def from_dict(cls, d):
 1106        return cls(
 1107            meta=d.get('meta'),
 1108            rate_limit=d.get('rate_limit'),
 1109        )
 1110
 1111
 1112class AccountAttachmentGetResponse:
 1113    '''
 1114     AccountAttachmentGetResponse returns a requested AccountAttachment.
 1115    '''
 1116    __slots__ = [
 1117        'account_attachment',
 1118        'meta',
 1119        'rate_limit',
 1120    ]
 1121
 1122    def __init__(
 1123        self,
 1124        account_attachment=None,
 1125        meta=None,
 1126        rate_limit=None,
 1127    ):
 1128        self.account_attachment = account_attachment if account_attachment is not None else None
 1129        '''
 1130         The requested AccountAttachment.
 1131        '''
 1132        self.meta = meta if meta is not None else None
 1133        '''
 1134         Reserved for future use.
 1135        '''
 1136        self.rate_limit = rate_limit if rate_limit is not None else None
 1137        '''
 1138         Rate limit information.
 1139        '''
 1140
 1141    def __repr__(self):
 1142        return '<sdm.AccountAttachmentGetResponse ' + \
 1143            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
 1144            'meta: ' + repr(self.meta) + ' ' +\
 1145            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1146            '>'
 1147
 1148    def to_dict(self):
 1149        return {
 1150            'account_attachment': self.account_attachment,
 1151            'meta': self.meta,
 1152            'rate_limit': self.rate_limit,
 1153        }
 1154
 1155    @classmethod
 1156    def from_dict(cls, d):
 1157        return cls(
 1158            account_attachment=d.get('account_attachment'),
 1159            meta=d.get('meta'),
 1160            rate_limit=d.get('rate_limit'),
 1161        )
 1162
 1163
 1164class AccountCreateResponse:
 1165    '''
 1166     AccountCreateResponse reports how the Accounts were created in the system.
 1167    '''
 1168    __slots__ = [
 1169        'account',
 1170        'meta',
 1171        'rate_limit',
 1172        'token',
 1173    ]
 1174
 1175    def __init__(
 1176        self,
 1177        account=None,
 1178        meta=None,
 1179        rate_limit=None,
 1180        token=None,
 1181    ):
 1182        self.account = account if account is not None else None
 1183        '''
 1184         The created Account.
 1185        '''
 1186        self.meta = meta if meta is not None else None
 1187        '''
 1188         Reserved for future use.
 1189        '''
 1190        self.rate_limit = rate_limit if rate_limit is not None else None
 1191        '''
 1192         Rate limit information.
 1193        '''
 1194        self.token = token if token is not None else ''
 1195        '''
 1196         The auth token generated for the Account. The Account will use this token to
 1197         authenticate with the strongDM API.
 1198        '''
 1199
 1200    def __repr__(self):
 1201        return '<sdm.AccountCreateResponse ' + \
 1202            'account: ' + repr(self.account) + ' ' +\
 1203            'meta: ' + repr(self.meta) + ' ' +\
 1204            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1205            'token: ' + repr(self.token) + ' ' +\
 1206            '>'
 1207
 1208    def to_dict(self):
 1209        return {
 1210            'account': self.account,
 1211            'meta': self.meta,
 1212            'rate_limit': self.rate_limit,
 1213            'token': self.token,
 1214        }
 1215
 1216    @classmethod
 1217    def from_dict(cls, d):
 1218        return cls(
 1219            account=d.get('account'),
 1220            meta=d.get('meta'),
 1221            rate_limit=d.get('rate_limit'),
 1222            token=d.get('token'),
 1223        )
 1224
 1225
 1226class AccountDeleteResponse:
 1227    '''
 1228     AccountDeleteResponse returns information about a Account that was deleted.
 1229    '''
 1230    __slots__ = [
 1231        'meta',
 1232        'rate_limit',
 1233    ]
 1234
 1235    def __init__(
 1236        self,
 1237        meta=None,
 1238        rate_limit=None,
 1239    ):
 1240        self.meta = meta if meta is not None else None
 1241        '''
 1242         Reserved for future use.
 1243        '''
 1244        self.rate_limit = rate_limit if rate_limit is not None else None
 1245        '''
 1246         Rate limit information.
 1247        '''
 1248
 1249    def __repr__(self):
 1250        return '<sdm.AccountDeleteResponse ' + \
 1251            'meta: ' + repr(self.meta) + ' ' +\
 1252            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1253            '>'
 1254
 1255    def to_dict(self):
 1256        return {
 1257            'meta': self.meta,
 1258            'rate_limit': self.rate_limit,
 1259        }
 1260
 1261    @classmethod
 1262    def from_dict(cls, d):
 1263        return cls(
 1264            meta=d.get('meta'),
 1265            rate_limit=d.get('rate_limit'),
 1266        )
 1267
 1268
 1269class AccountGetResponse:
 1270    '''
 1271     AccountGetResponse returns a requested Account.
 1272    '''
 1273    __slots__ = [
 1274        'account',
 1275        'meta',
 1276        'rate_limit',
 1277    ]
 1278
 1279    def __init__(
 1280        self,
 1281        account=None,
 1282        meta=None,
 1283        rate_limit=None,
 1284    ):
 1285        self.account = account if account is not None else None
 1286        '''
 1287         The requested Account.
 1288        '''
 1289        self.meta = meta if meta is not None else None
 1290        '''
 1291         Reserved for future use.
 1292        '''
 1293        self.rate_limit = rate_limit if rate_limit is not None else None
 1294        '''
 1295         Rate limit information.
 1296        '''
 1297
 1298    def __repr__(self):
 1299        return '<sdm.AccountGetResponse ' + \
 1300            'account: ' + repr(self.account) + ' ' +\
 1301            'meta: ' + repr(self.meta) + ' ' +\
 1302            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1303            '>'
 1304
 1305    def to_dict(self):
 1306        return {
 1307            'account': self.account,
 1308            'meta': self.meta,
 1309            'rate_limit': self.rate_limit,
 1310        }
 1311
 1312    @classmethod
 1313    def from_dict(cls, d):
 1314        return cls(
 1315            account=d.get('account'),
 1316            meta=d.get('meta'),
 1317            rate_limit=d.get('rate_limit'),
 1318        )
 1319
 1320
 1321class AccountGrant:
 1322    '''
 1323     AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.
 1324    '''
 1325    __slots__ = [
 1326        'account_id',
 1327        'id',
 1328        'resource_id',
 1329        'start_from',
 1330        'valid_until',
 1331    ]
 1332
 1333    def __init__(
 1334        self,
 1335        account_id=None,
 1336        id=None,
 1337        resource_id=None,
 1338        start_from=None,
 1339        valid_until=None,
 1340    ):
 1341        self.account_id = account_id if account_id is not None else ''
 1342        '''
 1343         The account id of this AccountGrant.
 1344        '''
 1345        self.id = id if id is not None else ''
 1346        '''
 1347         Unique identifier of the AccountGrant.
 1348        '''
 1349        self.resource_id = resource_id if resource_id is not None else ''
 1350        '''
 1351         The resource id of this AccountGrant.
 1352        '''
 1353        self.start_from = start_from if start_from is not None else None
 1354        '''
 1355         The timestamp when the resource will be granted. Optional. Both start_at
 1356         and end_at must be defined together, or not defined at all.
 1357        '''
 1358        self.valid_until = valid_until if valid_until is not None else None
 1359        '''
 1360         The timestamp when the resource grant will expire. Optional. Both
 1361         start_at and end_at must be defined together, or not defined at all.
 1362        '''
 1363
 1364    def __repr__(self):
 1365        return '<sdm.AccountGrant ' + \
 1366            'account_id: ' + repr(self.account_id) + ' ' +\
 1367            'id: ' + repr(self.id) + ' ' +\
 1368            'resource_id: ' + repr(self.resource_id) + ' ' +\
 1369            'start_from: ' + repr(self.start_from) + ' ' +\
 1370            'valid_until: ' + repr(self.valid_until) + ' ' +\
 1371            '>'
 1372
 1373    def to_dict(self):
 1374        return {
 1375            'account_id': self.account_id,
 1376            'id': self.id,
 1377            'resource_id': self.resource_id,
 1378            'start_from': self.start_from,
 1379            'valid_until': self.valid_until,
 1380        }
 1381
 1382    @classmethod
 1383    def from_dict(cls, d):
 1384        return cls(
 1385            account_id=d.get('account_id'),
 1386            id=d.get('id'),
 1387            resource_id=d.get('resource_id'),
 1388            start_from=d.get('start_from'),
 1389            valid_until=d.get('valid_until'),
 1390        )
 1391
 1392
 1393class AccountGrantCreateResponse:
 1394    '''
 1395     AccountGrantCreateResponse reports how the AccountGrants were created in the system.
 1396    '''
 1397    __slots__ = [
 1398        'account_grant',
 1399        'meta',
 1400        'rate_limit',
 1401    ]
 1402
 1403    def __init__(
 1404        self,
 1405        account_grant=None,
 1406        meta=None,
 1407        rate_limit=None,
 1408    ):
 1409        self.account_grant = account_grant if account_grant is not None else None
 1410        '''
 1411         The created AccountGrant.
 1412        '''
 1413        self.meta = meta if meta is not None else None
 1414        '''
 1415         Reserved for future use.
 1416        '''
 1417        self.rate_limit = rate_limit if rate_limit is not None else None
 1418        '''
 1419         Rate limit information.
 1420        '''
 1421
 1422    def __repr__(self):
 1423        return '<sdm.AccountGrantCreateResponse ' + \
 1424            'account_grant: ' + repr(self.account_grant) + ' ' +\
 1425            'meta: ' + repr(self.meta) + ' ' +\
 1426            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1427            '>'
 1428
 1429    def to_dict(self):
 1430        return {
 1431            'account_grant': self.account_grant,
 1432            'meta': self.meta,
 1433            'rate_limit': self.rate_limit,
 1434        }
 1435
 1436    @classmethod
 1437    def from_dict(cls, d):
 1438        return cls(
 1439            account_grant=d.get('account_grant'),
 1440            meta=d.get('meta'),
 1441            rate_limit=d.get('rate_limit'),
 1442        )
 1443
 1444
 1445class AccountGrantDeleteResponse:
 1446    '''
 1447     AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.
 1448    '''
 1449    __slots__ = [
 1450        'meta',
 1451        'rate_limit',
 1452    ]
 1453
 1454    def __init__(
 1455        self,
 1456        meta=None,
 1457        rate_limit=None,
 1458    ):
 1459        self.meta = meta if meta is not None else None
 1460        '''
 1461         Reserved for future use.
 1462        '''
 1463        self.rate_limit = rate_limit if rate_limit is not None else None
 1464        '''
 1465         Rate limit information.
 1466        '''
 1467
 1468    def __repr__(self):
 1469        return '<sdm.AccountGrantDeleteResponse ' + \
 1470            'meta: ' + repr(self.meta) + ' ' +\
 1471            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1472            '>'
 1473
 1474    def to_dict(self):
 1475        return {
 1476            'meta': self.meta,
 1477            'rate_limit': self.rate_limit,
 1478        }
 1479
 1480    @classmethod
 1481    def from_dict(cls, d):
 1482        return cls(
 1483            meta=d.get('meta'),
 1484            rate_limit=d.get('rate_limit'),
 1485        )
 1486
 1487
 1488class AccountGrantGetResponse:
 1489    '''
 1490     AccountGrantGetResponse returns a requested AccountGrant.
 1491    '''
 1492    __slots__ = [
 1493        'account_grant',
 1494        'meta',
 1495        'rate_limit',
 1496    ]
 1497
 1498    def __init__(
 1499        self,
 1500        account_grant=None,
 1501        meta=None,
 1502        rate_limit=None,
 1503    ):
 1504        self.account_grant = account_grant if account_grant is not None else None
 1505        '''
 1506         The requested AccountGrant.
 1507        '''
 1508        self.meta = meta if meta is not None else None
 1509        '''
 1510         Reserved for future use.
 1511        '''
 1512        self.rate_limit = rate_limit if rate_limit is not None else None
 1513        '''
 1514         Rate limit information.
 1515        '''
 1516
 1517    def __repr__(self):
 1518        return '<sdm.AccountGrantGetResponse ' + \
 1519            'account_grant: ' + repr(self.account_grant) + ' ' +\
 1520            'meta: ' + repr(self.meta) + ' ' +\
 1521            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1522            '>'
 1523
 1524    def to_dict(self):
 1525        return {
 1526            'account_grant': self.account_grant,
 1527            'meta': self.meta,
 1528            'rate_limit': self.rate_limit,
 1529        }
 1530
 1531    @classmethod
 1532    def from_dict(cls, d):
 1533        return cls(
 1534            account_grant=d.get('account_grant'),
 1535            meta=d.get('meta'),
 1536            rate_limit=d.get('rate_limit'),
 1537        )
 1538
 1539
 1540class AccountUpdateResponse:
 1541    '''
 1542     AccountUpdateResponse returns the fields of a Account after it has been updated by
 1543     a AccountUpdateRequest.
 1544    '''
 1545    __slots__ = [
 1546        'account',
 1547        'meta',
 1548        'rate_limit',
 1549    ]
 1550
 1551    def __init__(
 1552        self,
 1553        account=None,
 1554        meta=None,
 1555        rate_limit=None,
 1556    ):
 1557        self.account = account if account is not None else None
 1558        '''
 1559         The updated Account.
 1560        '''
 1561        self.meta = meta if meta is not None else None
 1562        '''
 1563         Reserved for future use.
 1564        '''
 1565        self.rate_limit = rate_limit if rate_limit is not None else None
 1566        '''
 1567         Rate limit information.
 1568        '''
 1569
 1570    def __repr__(self):
 1571        return '<sdm.AccountUpdateResponse ' + \
 1572            'account: ' + repr(self.account) + ' ' +\
 1573            'meta: ' + repr(self.meta) + ' ' +\
 1574            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1575            '>'
 1576
 1577    def to_dict(self):
 1578        return {
 1579            'account': self.account,
 1580            'meta': self.meta,
 1581            'rate_limit': self.rate_limit,
 1582        }
 1583
 1584    @classmethod
 1585    def from_dict(cls, d):
 1586        return cls(
 1587            account=d.get('account'),
 1588            meta=d.get('meta'),
 1589            rate_limit=d.get('rate_limit'),
 1590        )
 1591
 1592
 1593class AmazonEKS:
 1594    '''
 1595
 1596    '''
 1597    __slots__ = [
 1598        'access_key',
 1599        'bind_interface',
 1600        'certificate_authority',
 1601        'cluster_name',
 1602        'egress_filter',
 1603        'endpoint',
 1604        'healthcheck_namespace',
 1605        'healthy',
 1606        'id',
 1607        'name',
 1608        'region',
 1609        'remote_identity_group_id',
 1610        'remote_identity_healthcheck_username',
 1611        'role_arn',
 1612        'role_external_id',
 1613        'secret_access_key',
 1614        'secret_store_id',
 1615        'tags',
 1616    ]
 1617
 1618    def __init__(
 1619        self,
 1620        access_key=None,
 1621        bind_interface=None,
 1622        certificate_authority=None,
 1623        cluster_name=None,
 1624        egress_filter=None,
 1625        endpoint=None,
 1626        healthcheck_namespace=None,
 1627        healthy=None,
 1628        id=None,
 1629        name=None,
 1630        region=None,
 1631        remote_identity_group_id=None,
 1632        remote_identity_healthcheck_username=None,
 1633        role_arn=None,
 1634        role_external_id=None,
 1635        secret_access_key=None,
 1636        secret_store_id=None,
 1637        tags=None,
 1638    ):
 1639        self.access_key = access_key if access_key is not None else ''
 1640        '''
 1641
 1642        '''
 1643        self.bind_interface = bind_interface if bind_interface is not None else ''
 1644        '''
 1645         Bind interface
 1646        '''
 1647        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 1648        '''
 1649
 1650        '''
 1651        self.cluster_name = cluster_name if cluster_name is not None else ''
 1652        '''
 1653
 1654        '''
 1655        self.egress_filter = egress_filter if egress_filter is not None else ''
 1656        '''
 1657         A filter applied to the routing logic to pin datasource to nodes.
 1658        '''
 1659        self.endpoint = endpoint if endpoint is not None else ''
 1660        '''
 1661
 1662        '''
 1663        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 1664        '''
 1665         The path used to check the health of your connection.  Defaults to `default`.
 1666        '''
 1667        self.healthy = healthy if healthy is not None else False
 1668        '''
 1669         True if the datasource is reachable and the credentials are valid.
 1670        '''
 1671        self.id = id if id is not None else ''
 1672        '''
 1673         Unique identifier of the Resource.
 1674        '''
 1675        self.name = name if name is not None else ''
 1676        '''
 1677         Unique human-readable name of the Resource.
 1678        '''
 1679        self.region = region if region is not None else ''
 1680        '''
 1681
 1682        '''
 1683        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 1684        '''
 1685
 1686        '''
 1687        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 1688        '''
 1689
 1690        '''
 1691        self.role_arn = role_arn if role_arn is not None else ''
 1692        '''
 1693
 1694        '''
 1695        self.role_external_id = role_external_id if role_external_id is not None else ''
 1696        '''
 1697
 1698        '''
 1699        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 1700        '''
 1701
 1702        '''
 1703        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1704        '''
 1705         ID of the secret store containing credentials for this resource, if any.
 1706        '''
 1707        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1708        '''
 1709         Tags is a map of key, value pairs.
 1710        '''
 1711
 1712    def __repr__(self):
 1713        return '<sdm.AmazonEKS ' + \
 1714            'access_key: ' + repr(self.access_key) + ' ' +\
 1715            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 1716            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 1717            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
 1718            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 1719            'endpoint: ' + repr(self.endpoint) + ' ' +\
 1720            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 1721            'healthy: ' + repr(self.healthy) + ' ' +\
 1722            'id: ' + repr(self.id) + ' ' +\
 1723            'name: ' + repr(self.name) + ' ' +\
 1724            'region: ' + repr(self.region) + ' ' +\
 1725            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 1726            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 1727            'role_arn: ' + repr(self.role_arn) + ' ' +\
 1728            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 1729            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 1730            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 1731            'tags: ' + repr(self.tags) + ' ' +\
 1732            '>'
 1733
 1734    def to_dict(self):
 1735        return {
 1736            'access_key': self.access_key,
 1737            'bind_interface': self.bind_interface,
 1738            'certificate_authority': self.certificate_authority,
 1739            'cluster_name': self.cluster_name,
 1740            'egress_filter': self.egress_filter,
 1741            'endpoint': self.endpoint,
 1742            'healthcheck_namespace': self.healthcheck_namespace,
 1743            'healthy': self.healthy,
 1744            'id': self.id,
 1745            'name': self.name,
 1746            'region': self.region,
 1747            'remote_identity_group_id': self.remote_identity_group_id,
 1748            'remote_identity_healthcheck_username':
 1749            self.remote_identity_healthcheck_username,
 1750            'role_arn': self.role_arn,
 1751            'role_external_id': self.role_external_id,
 1752            'secret_access_key': self.secret_access_key,
 1753            'secret_store_id': self.secret_store_id,
 1754            'tags': self.tags,
 1755        }
 1756
 1757    @classmethod
 1758    def from_dict(cls, d):
 1759        return cls(
 1760            access_key=d.get('access_key'),
 1761            bind_interface=d.get('bind_interface'),
 1762            certificate_authority=d.get('certificate_authority'),
 1763            cluster_name=d.get('cluster_name'),
 1764            egress_filter=d.get('egress_filter'),
 1765            endpoint=d.get('endpoint'),
 1766            healthcheck_namespace=d.get('healthcheck_namespace'),
 1767            healthy=d.get('healthy'),
 1768            id=d.get('id'),
 1769            name=d.get('name'),
 1770            region=d.get('region'),
 1771            remote_identity_group_id=d.get('remote_identity_group_id'),
 1772            remote_identity_healthcheck_username=d.get(
 1773                'remote_identity_healthcheck_username'),
 1774            role_arn=d.get('role_arn'),
 1775            role_external_id=d.get('role_external_id'),
 1776            secret_access_key=d.get('secret_access_key'),
 1777            secret_store_id=d.get('secret_store_id'),
 1778            tags=d.get('tags'),
 1779        )
 1780
 1781
 1782class AmazonEKSUserImpersonation:
 1783    '''
 1784
 1785    '''
 1786    __slots__ = [
 1787        'access_key',
 1788        'bind_interface',
 1789        'certificate_authority',
 1790        'cluster_name',
 1791        'egress_filter',
 1792        'endpoint',
 1793        'healthcheck_namespace',
 1794        'healthy',
 1795        'id',
 1796        'name',
 1797        'region',
 1798        'role_arn',
 1799        'role_external_id',
 1800        'secret_access_key',
 1801        'secret_store_id',
 1802        'tags',
 1803    ]
 1804
 1805    def __init__(
 1806        self,
 1807        access_key=None,
 1808        bind_interface=None,
 1809        certificate_authority=None,
 1810        cluster_name=None,
 1811        egress_filter=None,
 1812        endpoint=None,
 1813        healthcheck_namespace=None,
 1814        healthy=None,
 1815        id=None,
 1816        name=None,
 1817        region=None,
 1818        role_arn=None,
 1819        role_external_id=None,
 1820        secret_access_key=None,
 1821        secret_store_id=None,
 1822        tags=None,
 1823    ):
 1824        self.access_key = access_key if access_key is not None else ''
 1825        '''
 1826
 1827        '''
 1828        self.bind_interface = bind_interface if bind_interface is not None else ''
 1829        '''
 1830         Bind interface
 1831        '''
 1832        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 1833        '''
 1834
 1835        '''
 1836        self.cluster_name = cluster_name if cluster_name is not None else ''
 1837        '''
 1838
 1839        '''
 1840        self.egress_filter = egress_filter if egress_filter is not None else ''
 1841        '''
 1842         A filter applied to the routing logic to pin datasource to nodes.
 1843        '''
 1844        self.endpoint = endpoint if endpoint is not None else ''
 1845        '''
 1846
 1847        '''
 1848        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 1849        '''
 1850         The path used to check the health of your connection.  Defaults to `default`.
 1851        '''
 1852        self.healthy = healthy if healthy is not None else False
 1853        '''
 1854         True if the datasource is reachable and the credentials are valid.
 1855        '''
 1856        self.id = id if id is not None else ''
 1857        '''
 1858         Unique identifier of the Resource.
 1859        '''
 1860        self.name = name if name is not None else ''
 1861        '''
 1862         Unique human-readable name of the Resource.
 1863        '''
 1864        self.region = region if region is not None else ''
 1865        '''
 1866
 1867        '''
 1868        self.role_arn = role_arn if role_arn is not None else ''
 1869        '''
 1870
 1871        '''
 1872        self.role_external_id = role_external_id if role_external_id is not None else ''
 1873        '''
 1874
 1875        '''
 1876        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 1877        '''
 1878
 1879        '''
 1880        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1881        '''
 1882         ID of the secret store containing credentials for this resource, if any.
 1883        '''
 1884        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1885        '''
 1886         Tags is a map of key, value pairs.
 1887        '''
 1888
 1889    def __repr__(self):
 1890        return '<sdm.AmazonEKSUserImpersonation ' + \
 1891            'access_key: ' + repr(self.access_key) + ' ' +\
 1892            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 1893            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 1894            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
 1895            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 1896            'endpoint: ' + repr(self.endpoint) + ' ' +\
 1897            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 1898            'healthy: ' + repr(self.healthy) + ' ' +\
 1899            'id: ' + repr(self.id) + ' ' +\
 1900            'name: ' + repr(self.name) + ' ' +\
 1901            'region: ' + repr(self.region) + ' ' +\
 1902            'role_arn: ' + repr(self.role_arn) + ' ' +\
 1903            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 1904            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 1905            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 1906            'tags: ' + repr(self.tags) + ' ' +\
 1907            '>'
 1908
 1909    def to_dict(self):
 1910        return {
 1911            'access_key': self.access_key,
 1912            'bind_interface': self.bind_interface,
 1913            'certificate_authority': self.certificate_authority,
 1914            'cluster_name': self.cluster_name,
 1915            'egress_filter': self.egress_filter,
 1916            'endpoint': self.endpoint,
 1917            'healthcheck_namespace': self.healthcheck_namespace,
 1918            'healthy': self.healthy,
 1919            'id': self.id,
 1920            'name': self.name,
 1921            'region': self.region,
 1922            'role_arn': self.role_arn,
 1923            'role_external_id': self.role_external_id,
 1924            'secret_access_key': self.secret_access_key,
 1925            'secret_store_id': self.secret_store_id,
 1926            'tags': self.tags,
 1927        }
 1928
 1929    @classmethod
 1930    def from_dict(cls, d):
 1931        return cls(
 1932            access_key=d.get('access_key'),
 1933            bind_interface=d.get('bind_interface'),
 1934            certificate_authority=d.get('certificate_authority'),
 1935            cluster_name=d.get('cluster_name'),
 1936            egress_filter=d.get('egress_filter'),
 1937            endpoint=d.get('endpoint'),
 1938            healthcheck_namespace=d.get('healthcheck_namespace'),
 1939            healthy=d.get('healthy'),
 1940            id=d.get('id'),
 1941            name=d.get('name'),
 1942            region=d.get('region'),
 1943            role_arn=d.get('role_arn'),
 1944            role_external_id=d.get('role_external_id'),
 1945            secret_access_key=d.get('secret_access_key'),
 1946            secret_store_id=d.get('secret_store_id'),
 1947            tags=d.get('tags'),
 1948        )
 1949
 1950
 1951class AmazonES:
 1952    '''
 1953
 1954    '''
 1955    __slots__ = [
 1956        'access_key',
 1957        'bind_interface',
 1958        'egress_filter',
 1959        'endpoint',
 1960        'healthy',
 1961        'id',
 1962        'name',
 1963        'port_override',
 1964        'region',
 1965        'role_arn',
 1966        'role_external_id',
 1967        'secret_access_key',
 1968        'secret_store_id',
 1969        'tags',
 1970    ]
 1971
 1972    def __init__(
 1973        self,
 1974        access_key=None,
 1975        bind_interface=None,
 1976        egress_filter=None,
 1977        endpoint=None,
 1978        healthy=None,
 1979        id=None,
 1980        name=None,
 1981        port_override=None,
 1982        region=None,
 1983        role_arn=None,
 1984        role_external_id=None,
 1985        secret_access_key=None,
 1986        secret_store_id=None,
 1987        tags=None,
 1988    ):
 1989        self.access_key = access_key if access_key is not None else ''
 1990        '''
 1991
 1992        '''
 1993        self.bind_interface = bind_interface if bind_interface is not None else ''
 1994        '''
 1995         Bind interface
 1996        '''
 1997        self.egress_filter = egress_filter if egress_filter is not None else ''
 1998        '''
 1999         A filter applied to the routing logic to pin datasource to nodes.
 2000        '''
 2001        self.endpoint = endpoint if endpoint is not None else ''
 2002        '''
 2003
 2004        '''
 2005        self.healthy = healthy if healthy is not None else False
 2006        '''
 2007         True if the datasource is reachable and the credentials are valid.
 2008        '''
 2009        self.id = id if id is not None else ''
 2010        '''
 2011         Unique identifier of the Resource.
 2012        '''
 2013        self.name = name if name is not None else ''
 2014        '''
 2015         Unique human-readable name of the Resource.
 2016        '''
 2017        self.port_override = port_override if port_override is not None else 0
 2018        '''
 2019
 2020        '''
 2021        self.region = region if region is not None else ''
 2022        '''
 2023
 2024        '''
 2025        self.role_arn = role_arn if role_arn is not None else ''
 2026        '''
 2027
 2028        '''
 2029        self.role_external_id = role_external_id if role_external_id is not None else ''
 2030        '''
 2031
 2032        '''
 2033        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 2034        '''
 2035
 2036        '''
 2037        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2038        '''
 2039         ID of the secret store containing credentials for this resource, if any.
 2040        '''
 2041        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2042        '''
 2043         Tags is a map of key, value pairs.
 2044        '''
 2045
 2046    def __repr__(self):
 2047        return '<sdm.AmazonES ' + \
 2048            'access_key: ' + repr(self.access_key) + ' ' +\
 2049            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2050            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2051            'endpoint: ' + repr(self.endpoint) + ' ' +\
 2052            'healthy: ' + repr(self.healthy) + ' ' +\
 2053            'id: ' + repr(self.id) + ' ' +\
 2054            'name: ' + repr(self.name) + ' ' +\
 2055            'port_override: ' + repr(self.port_override) + ' ' +\
 2056            'region: ' + repr(self.region) + ' ' +\
 2057            'role_arn: ' + repr(self.role_arn) + ' ' +\
 2058            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 2059            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 2060            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2061            'tags: ' + repr(self.tags) + ' ' +\
 2062            '>'
 2063
 2064    def to_dict(self):
 2065        return {
 2066            'access_key': self.access_key,
 2067            'bind_interface': self.bind_interface,
 2068            'egress_filter': self.egress_filter,
 2069            'endpoint': self.endpoint,
 2070            'healthy': self.healthy,
 2071            'id': self.id,
 2072            'name': self.name,
 2073            'port_override': self.port_override,
 2074            'region': self.region,
 2075            'role_arn': self.role_arn,
 2076            'role_external_id': self.role_external_id,
 2077            'secret_access_key': self.secret_access_key,
 2078            'secret_store_id': self.secret_store_id,
 2079            'tags': self.tags,
 2080        }
 2081
 2082    @classmethod
 2083    def from_dict(cls, d):
 2084        return cls(
 2085            access_key=d.get('access_key'),
 2086            bind_interface=d.get('bind_interface'),
 2087            egress_filter=d.get('egress_filter'),
 2088            endpoint=d.get('endpoint'),
 2089            healthy=d.get('healthy'),
 2090            id=d.get('id'),
 2091            name=d.get('name'),
 2092            port_override=d.get('port_override'),
 2093            region=d.get('region'),
 2094            role_arn=d.get('role_arn'),
 2095            role_external_id=d.get('role_external_id'),
 2096            secret_access_key=d.get('secret_access_key'),
 2097            secret_store_id=d.get('secret_store_id'),
 2098            tags=d.get('tags'),
 2099        )
 2100
 2101
 2102class AmazonMQAMQP091:
 2103    '''
 2104
 2105    '''
 2106    __slots__ = [
 2107        'bind_interface',
 2108        'egress_filter',
 2109        'healthy',
 2110        'hostname',
 2111        'id',
 2112        'name',
 2113        'password',
 2114        'port',
 2115        'port_override',
 2116        'secret_store_id',
 2117        'tags',
 2118        'tls_required',
 2119        'username',
 2120    ]
 2121
 2122    def __init__(
 2123        self,
 2124        bind_interface=None,
 2125        egress_filter=None,
 2126        healthy=None,
 2127        hostname=None,
 2128        id=None,
 2129        name=None,
 2130        password=None,
 2131        port=None,
 2132        port_override=None,
 2133        secret_store_id=None,
 2134        tags=None,
 2135        tls_required=None,
 2136        username=None,
 2137    ):
 2138        self.bind_interface = bind_interface if bind_interface is not None else ''
 2139        '''
 2140         Bind interface
 2141        '''
 2142        self.egress_filter = egress_filter if egress_filter is not None else ''
 2143        '''
 2144         A filter applied to the routing logic to pin datasource to nodes.
 2145        '''
 2146        self.healthy = healthy if healthy is not None else False
 2147        '''
 2148         True if the datasource is reachable and the credentials are valid.
 2149        '''
 2150        self.hostname = hostname if hostname is not None else ''
 2151        '''
 2152
 2153        '''
 2154        self.id = id if id is not None else ''
 2155        '''
 2156         Unique identifier of the Resource.
 2157        '''
 2158        self.name = name if name is not None else ''
 2159        '''
 2160         Unique human-readable name of the Resource.
 2161        '''
 2162        self.password = password if password is not None else ''
 2163        '''
 2164
 2165        '''
 2166        self.port = port if port is not None else 0
 2167        '''
 2168
 2169        '''
 2170        self.port_override = port_override if port_override is not None else 0
 2171        '''
 2172
 2173        '''
 2174        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2175        '''
 2176         ID of the secret store containing credentials for this resource, if any.
 2177        '''
 2178        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2179        '''
 2180         Tags is a map of key, value pairs.
 2181        '''
 2182        self.tls_required = tls_required if tls_required is not None else False
 2183        '''
 2184
 2185        '''
 2186        self.username = username if username is not None else ''
 2187        '''
 2188
 2189        '''
 2190
 2191    def __repr__(self):
 2192        return '<sdm.AmazonMQAMQP091 ' + \
 2193            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2194            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2195            'healthy: ' + repr(self.healthy) + ' ' +\
 2196            'hostname: ' + repr(self.hostname) + ' ' +\
 2197            'id: ' + repr(self.id) + ' ' +\
 2198            'name: ' + repr(self.name) + ' ' +\
 2199            'password: ' + repr(self.password) + ' ' +\
 2200            'port: ' + repr(self.port) + ' ' +\
 2201            'port_override: ' + repr(self.port_override) + ' ' +\
 2202            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2203            'tags: ' + repr(self.tags) + ' ' +\
 2204            'tls_required: ' + repr(self.tls_required) + ' ' +\
 2205            'username: ' + repr(self.username) + ' ' +\
 2206            '>'
 2207
 2208    def to_dict(self):
 2209        return {
 2210            'bind_interface': self.bind_interface,
 2211            'egress_filter': self.egress_filter,
 2212            'healthy': self.healthy,
 2213            'hostname': self.hostname,
 2214            'id': self.id,
 2215            'name': self.name,
 2216            'password': self.password,
 2217            'port': self.port,
 2218            'port_override': self.port_override,
 2219            'secret_store_id': self.secret_store_id,
 2220            'tags': self.tags,
 2221            'tls_required': self.tls_required,
 2222            'username': self.username,
 2223        }
 2224
 2225    @classmethod
 2226    def from_dict(cls, d):
 2227        return cls(
 2228            bind_interface=d.get('bind_interface'),
 2229            egress_filter=d.get('egress_filter'),
 2230            healthy=d.get('healthy'),
 2231            hostname=d.get('hostname'),
 2232            id=d.get('id'),
 2233            name=d.get('name'),
 2234            password=d.get('password'),
 2235            port=d.get('port'),
 2236            port_override=d.get('port_override'),
 2237            secret_store_id=d.get('secret_store_id'),
 2238            tags=d.get('tags'),
 2239            tls_required=d.get('tls_required'),
 2240            username=d.get('username'),
 2241        )
 2242
 2243
 2244class Athena:
 2245    '''
 2246
 2247    '''
 2248    __slots__ = [
 2249        'access_key',
 2250        'bind_interface',
 2251        'egress_filter',
 2252        'healthy',
 2253        'id',
 2254        'name',
 2255        'output',
 2256        'port_override',
 2257        'region',
 2258        'role_arn',
 2259        'role_external_id',
 2260        'secret_access_key',
 2261        'secret_store_id',
 2262        'tags',
 2263    ]
 2264
 2265    def __init__(
 2266        self,
 2267        access_key=None,
 2268        bind_interface=None,
 2269        egress_filter=None,
 2270        healthy=None,
 2271        id=None,
 2272        name=None,
 2273        output=None,
 2274        port_override=None,
 2275        region=None,
 2276        role_arn=None,
 2277        role_external_id=None,
 2278        secret_access_key=None,
 2279        secret_store_id=None,
 2280        tags=None,
 2281    ):
 2282        self.access_key = access_key if access_key is not None else ''
 2283        '''
 2284
 2285        '''
 2286        self.bind_interface = bind_interface if bind_interface is not None else ''
 2287        '''
 2288         Bind interface
 2289        '''
 2290        self.egress_filter = egress_filter if egress_filter is not None else ''
 2291        '''
 2292         A filter applied to the routing logic to pin datasource to nodes.
 2293        '''
 2294        self.healthy = healthy if healthy is not None else False
 2295        '''
 2296         True if the datasource is reachable and the credentials are valid.
 2297        '''
 2298        self.id = id if id is not None else ''
 2299        '''
 2300         Unique identifier of the Resource.
 2301        '''
 2302        self.name = name if name is not None else ''
 2303        '''
 2304         Unique human-readable name of the Resource.
 2305        '''
 2306        self.output = output if output is not None else ''
 2307        '''
 2308
 2309        '''
 2310        self.port_override = port_override if port_override is not None else 0
 2311        '''
 2312
 2313        '''
 2314        self.region = region if region is not None else ''
 2315        '''
 2316
 2317        '''
 2318        self.role_arn = role_arn if role_arn is not None else ''
 2319        '''
 2320
 2321        '''
 2322        self.role_external_id = role_external_id if role_external_id is not None else ''
 2323        '''
 2324
 2325        '''
 2326        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 2327        '''
 2328
 2329        '''
 2330        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2331        '''
 2332         ID of the secret store containing credentials for this resource, if any.
 2333        '''
 2334        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2335        '''
 2336         Tags is a map of key, value pairs.
 2337        '''
 2338
 2339    def __repr__(self):
 2340        return '<sdm.Athena ' + \
 2341            'access_key: ' + repr(self.access_key) + ' ' +\
 2342            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2343            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2344            'healthy: ' + repr(self.healthy) + ' ' +\
 2345            'id: ' + repr(self.id) + ' ' +\
 2346            'name: ' + repr(self.name) + ' ' +\
 2347            'output: ' + repr(self.output) + ' ' +\
 2348            'port_override: ' + repr(self.port_override) + ' ' +\
 2349            'region: ' + repr(self.region) + ' ' +\
 2350            'role_arn: ' + repr(self.role_arn) + ' ' +\
 2351            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 2352            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 2353            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2354            'tags: ' + repr(self.tags) + ' ' +\
 2355            '>'
 2356
 2357    def to_dict(self):
 2358        return {
 2359            'access_key': self.access_key,
 2360            'bind_interface': self.bind_interface,
 2361            'egress_filter': self.egress_filter,
 2362            'healthy': self.healthy,
 2363            'id': self.id,
 2364            'name': self.name,
 2365            'output': self.output,
 2366            'port_override': self.port_override,
 2367            'region': self.region,
 2368            'role_arn': self.role_arn,
 2369            'role_external_id': self.role_external_id,
 2370            'secret_access_key': self.secret_access_key,
 2371            'secret_store_id': self.secret_store_id,
 2372            'tags': self.tags,
 2373        }
 2374
 2375    @classmethod
 2376    def from_dict(cls, d):
 2377        return cls(
 2378            access_key=d.get('access_key'),
 2379            bind_interface=d.get('bind_interface'),
 2380            egress_filter=d.get('egress_filter'),
 2381            healthy=d.get('healthy'),
 2382            id=d.get('id'),
 2383            name=d.get('name'),
 2384            output=d.get('output'),
 2385            port_override=d.get('port_override'),
 2386            region=d.get('region'),
 2387            role_arn=d.get('role_arn'),
 2388            role_external_id=d.get('role_external_id'),
 2389            secret_access_key=d.get('secret_access_key'),
 2390            secret_store_id=d.get('secret_store_id'),
 2391            tags=d.get('tags'),
 2392        )
 2393
 2394
 2395class AuroraMysql:
 2396    '''
 2397
 2398    '''
 2399    __slots__ = [
 2400        'bind_interface',
 2401        'database',
 2402        'egress_filter',
 2403        'healthy',
 2404        'hostname',
 2405        'id',
 2406        'name',
 2407        'password',
 2408        'port',
 2409        'port_override',
 2410        'secret_store_id',
 2411        'tags',
 2412        'username',
 2413    ]
 2414
 2415    def __init__(
 2416        self,
 2417        bind_interface=None,
 2418        database=None,
 2419        egress_filter=None,
 2420        healthy=None,
 2421        hostname=None,
 2422        id=None,
 2423        name=None,
 2424        password=None,
 2425        port=None,
 2426        port_override=None,
 2427        secret_store_id=None,
 2428        tags=None,
 2429        username=None,
 2430    ):
 2431        self.bind_interface = bind_interface if bind_interface is not None else ''
 2432        '''
 2433         Bind interface
 2434        '''
 2435        self.database = database if database is not None else ''
 2436        '''
 2437
 2438        '''
 2439        self.egress_filter = egress_filter if egress_filter is not None else ''
 2440        '''
 2441         A filter applied to the routing logic to pin datasource to nodes.
 2442        '''
 2443        self.healthy = healthy if healthy is not None else False
 2444        '''
 2445         True if the datasource is reachable and the credentials are valid.
 2446        '''
 2447        self.hostname = hostname if hostname is not None else ''
 2448        '''
 2449
 2450        '''
 2451        self.id = id if id is not None else ''
 2452        '''
 2453         Unique identifier of the Resource.
 2454        '''
 2455        self.name = name if name is not None else ''
 2456        '''
 2457         Unique human-readable name of the Resource.
 2458        '''
 2459        self.password = password if password is not None else ''
 2460        '''
 2461
 2462        '''
 2463        self.port = port if port is not None else 0
 2464        '''
 2465
 2466        '''
 2467        self.port_override = port_override if port_override is not None else 0
 2468        '''
 2469
 2470        '''
 2471        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2472        '''
 2473         ID of the secret store containing credentials for this resource, if any.
 2474        '''
 2475        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2476        '''
 2477         Tags is a map of key, value pairs.
 2478        '''
 2479        self.username = username if username is not None else ''
 2480        '''
 2481
 2482        '''
 2483
 2484    def __repr__(self):
 2485        return '<sdm.AuroraMysql ' + \
 2486            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2487            'database: ' + repr(self.database) + ' ' +\
 2488            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2489            'healthy: ' + repr(self.healthy) + ' ' +\
 2490            'hostname: ' + repr(self.hostname) + ' ' +\
 2491            'id: ' + repr(self.id) + ' ' +\
 2492            'name: ' + repr(self.name) + ' ' +\
 2493            'password: ' + repr(self.password) + ' ' +\
 2494            'port: ' + repr(self.port) + ' ' +\
 2495            'port_override: ' + repr(self.port_override) + ' ' +\
 2496            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2497            'tags: ' + repr(self.tags) + ' ' +\
 2498            'username: ' + repr(self.username) + ' ' +\
 2499            '>'
 2500
 2501    def to_dict(self):
 2502        return {
 2503            'bind_interface': self.bind_interface,
 2504            'database': self.database,
 2505            'egress_filter': self.egress_filter,
 2506            'healthy': self.healthy,
 2507            'hostname': self.hostname,
 2508            'id': self.id,
 2509            'name': self.name,
 2510            'password': self.password,
 2511            'port': self.port,
 2512            'port_override': self.port_override,
 2513            'secret_store_id': self.secret_store_id,
 2514            'tags': self.tags,
 2515            'username': self.username,
 2516        }
 2517
 2518    @classmethod
 2519    def from_dict(cls, d):
 2520        return cls(
 2521            bind_interface=d.get('bind_interface'),
 2522            database=d.get('database'),
 2523            egress_filter=d.get('egress_filter'),
 2524            healthy=d.get('healthy'),
 2525            hostname=d.get('hostname'),
 2526            id=d.get('id'),
 2527            name=d.get('name'),
 2528            password=d.get('password'),
 2529            port=d.get('port'),
 2530            port_override=d.get('port_override'),
 2531            secret_store_id=d.get('secret_store_id'),
 2532            tags=d.get('tags'),
 2533            username=d.get('username'),
 2534        )
 2535
 2536
 2537class AuroraPostgres:
 2538    '''
 2539
 2540    '''
 2541    __slots__ = [
 2542        'bind_interface',
 2543        'database',
 2544        'egress_filter',
 2545        'healthy',
 2546        'hostname',
 2547        'id',
 2548        'name',
 2549        'override_database',
 2550        'password',
 2551        'port',
 2552        'port_override',
 2553        'secret_store_id',
 2554        'tags',
 2555        'username',
 2556    ]
 2557
 2558    def __init__(
 2559        self,
 2560        bind_interface=None,
 2561        database=None,
 2562        egress_filter=None,
 2563        healthy=None,
 2564        hostname=None,
 2565        id=None,
 2566        name=None,
 2567        override_database=None,
 2568        password=None,
 2569        port=None,
 2570        port_override=None,
 2571        secret_store_id=None,
 2572        tags=None,
 2573        username=None,
 2574    ):
 2575        self.bind_interface = bind_interface if bind_interface is not None else ''
 2576        '''
 2577         Bind interface
 2578        '''
 2579        self.database = database if database is not None else ''
 2580        '''
 2581
 2582        '''
 2583        self.egress_filter = egress_filter if egress_filter is not None else ''
 2584        '''
 2585         A filter applied to the routing logic to pin datasource to nodes.
 2586        '''
 2587        self.healthy = healthy if healthy is not None else False
 2588        '''
 2589         True if the datasource is reachable and the credentials are valid.
 2590        '''
 2591        self.hostname = hostname if hostname is not None else ''
 2592        '''
 2593
 2594        '''
 2595        self.id = id if id is not None else ''
 2596        '''
 2597         Unique identifier of the Resource.
 2598        '''
 2599        self.name = name if name is not None else ''
 2600        '''
 2601         Unique human-readable name of the Resource.
 2602        '''
 2603        self.override_database = override_database if override_database is not None else False
 2604        '''
 2605
 2606        '''
 2607        self.password = password if password is not None else ''
 2608        '''
 2609
 2610        '''
 2611        self.port = port if port is not None else 0
 2612        '''
 2613
 2614        '''
 2615        self.port_override = port_override if port_override is not None else 0
 2616        '''
 2617
 2618        '''
 2619        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2620        '''
 2621         ID of the secret store containing credentials for this resource, if any.
 2622        '''
 2623        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2624        '''
 2625         Tags is a map of key, value pairs.
 2626        '''
 2627        self.username = username if username is not None else ''
 2628        '''
 2629
 2630        '''
 2631
 2632    def __repr__(self):
 2633        return '<sdm.AuroraPostgres ' + \
 2634            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2635            'database: ' + repr(self.database) + ' ' +\
 2636            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2637            'healthy: ' + repr(self.healthy) + ' ' +\
 2638            'hostname: ' + repr(self.hostname) + ' ' +\
 2639            'id: ' + repr(self.id) + ' ' +\
 2640            'name: ' + repr(self.name) + ' ' +\
 2641            'override_database: ' + repr(self.override_database) + ' ' +\
 2642            'password: ' + repr(self.password) + ' ' +\
 2643            'port: ' + repr(self.port) + ' ' +\
 2644            'port_override: ' + repr(self.port_override) + ' ' +\
 2645            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2646            'tags: ' + repr(self.tags) + ' ' +\
 2647            'username: ' + repr(self.username) + ' ' +\
 2648            '>'
 2649
 2650    def to_dict(self):
 2651        return {
 2652            'bind_interface': self.bind_interface,
 2653            'database': self.database,
 2654            'egress_filter': self.egress_filter,
 2655            'healthy': self.healthy,
 2656            'hostname': self.hostname,
 2657            'id': self.id,
 2658            'name': self.name,
 2659            'override_database': self.override_database,
 2660            'password': self.password,
 2661            'port': self.port,
 2662            'port_override': self.port_override,
 2663            'secret_store_id': self.secret_store_id,
 2664            'tags': self.tags,
 2665            'username': self.username,
 2666        }
 2667
 2668    @classmethod
 2669    def from_dict(cls, d):
 2670        return cls(
 2671            bind_interface=d.get('bind_interface'),
 2672            database=d.get('database'),
 2673            egress_filter=d.get('egress_filter'),
 2674            healthy=d.get('healthy'),
 2675            hostname=d.get('hostname'),
 2676            id=d.get('id'),
 2677            name=d.get('name'),
 2678            override_database=d.get('override_database'),
 2679            password=d.get('password'),
 2680            port=d.get('port'),
 2681            port_override=d.get('port_override'),
 2682            secret_store_id=d.get('secret_store_id'),
 2683            tags=d.get('tags'),
 2684            username=d.get('username'),
 2685        )
 2686
 2687
 2688class Azure:
 2689    '''
 2690
 2691    '''
 2692    __slots__ = [
 2693        'app_id',
 2694        'bind_interface',
 2695        'egress_filter',
 2696        'healthy',
 2697        'id',
 2698        'name',
 2699        'password',
 2700        'secret_store_id',
 2701        'tags',
 2702        'tenant_id',
 2703    ]
 2704
 2705    def __init__(
 2706        self,
 2707        app_id=None,
 2708        bind_interface=None,
 2709        egress_filter=None,
 2710        healthy=None,
 2711        id=None,
 2712        name=None,
 2713        password=None,
 2714        secret_store_id=None,
 2715        tags=None,
 2716        tenant_id=None,
 2717    ):
 2718        self.app_id = app_id if app_id is not None else ''
 2719        '''
 2720
 2721        '''
 2722        self.bind_interface = bind_interface if bind_interface is not None else ''
 2723        '''
 2724         Bind interface
 2725        '''
 2726        self.egress_filter = egress_filter if egress_filter is not None else ''
 2727        '''
 2728         A filter applied to the routing logic to pin datasource to nodes.
 2729        '''
 2730        self.healthy = healthy if healthy is not None else False
 2731        '''
 2732         True if the datasource is reachable and the credentials are valid.
 2733        '''
 2734        self.id = id if id is not None else ''
 2735        '''
 2736         Unique identifier of the Resource.
 2737        '''
 2738        self.name = name if name is not None else ''
 2739        '''
 2740         Unique human-readable name of the Resource.
 2741        '''
 2742        self.password = password if password is not None else ''
 2743        '''
 2744
 2745        '''
 2746        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2747        '''
 2748         ID of the secret store containing credentials for this resource, if any.
 2749        '''
 2750        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2751        '''
 2752         Tags is a map of key, value pairs.
 2753        '''
 2754        self.tenant_id = tenant_id if tenant_id is not None else ''
 2755        '''
 2756
 2757        '''
 2758
 2759    def __repr__(self):
 2760        return '<sdm.Azure ' + \
 2761            'app_id: ' + repr(self.app_id) + ' ' +\
 2762            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2763            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2764            'healthy: ' + repr(self.healthy) + ' ' +\
 2765            'id: ' + repr(self.id) + ' ' +\
 2766            'name: ' + repr(self.name) + ' ' +\
 2767            'password: ' + repr(self.password) + ' ' +\
 2768            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2769            'tags: ' + repr(self.tags) + ' ' +\
 2770            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
 2771            '>'
 2772
 2773    def to_dict(self):
 2774        return {
 2775            'app_id': self.app_id,
 2776            'bind_interface': self.bind_interface,
 2777            'egress_filter': self.egress_filter,
 2778            'healthy': self.healthy,
 2779            'id': self.id,
 2780            'name': self.name,
 2781            'password': self.password,
 2782            'secret_store_id': self.secret_store_id,
 2783            'tags': self.tags,
 2784            'tenant_id': self.tenant_id,
 2785        }
 2786
 2787    @classmethod
 2788    def from_dict(cls, d):
 2789        return cls(
 2790            app_id=d.get('app_id'),
 2791            bind_interface=d.get('bind_interface'),
 2792            egress_filter=d.get('egress_filter'),
 2793            healthy=d.get('healthy'),
 2794            id=d.get('id'),
 2795            name=d.get('name'),
 2796            password=d.get('password'),
 2797            secret_store_id=d.get('secret_store_id'),
 2798            tags=d.get('tags'),
 2799            tenant_id=d.get('tenant_id'),
 2800        )
 2801
 2802
 2803class AzureCertificate:
 2804    '''
 2805
 2806    '''
 2807    __slots__ = [
 2808        'app_id',
 2809        'bind_interface',
 2810        'client_certificate',
 2811        'egress_filter',
 2812        'healthy',
 2813        'id',
 2814        'name',
 2815        'secret_store_id',
 2816        'tags',
 2817        'tenant_id',
 2818    ]
 2819
 2820    def __init__(
 2821        self,
 2822        app_id=None,
 2823        bind_interface=None,
 2824        client_certificate=None,
 2825        egress_filter=None,
 2826        healthy=None,
 2827        id=None,
 2828        name=None,
 2829        secret_store_id=None,
 2830        tags=None,
 2831        tenant_id=None,
 2832    ):
 2833        self.app_id = app_id if app_id is not None else ''
 2834        '''
 2835
 2836        '''
 2837        self.bind_interface = bind_interface if bind_interface is not None else ''
 2838        '''
 2839         Bind interface
 2840        '''
 2841        self.client_certificate = client_certificate if client_certificate is not None else ''
 2842        '''
 2843
 2844        '''
 2845        self.egress_filter = egress_filter if egress_filter is not None else ''
 2846        '''
 2847         A filter applied to the routing logic to pin datasource to nodes.
 2848        '''
 2849        self.healthy = healthy if healthy is not None else False
 2850        '''
 2851         True if the datasource is reachable and the credentials are valid.
 2852        '''
 2853        self.id = id if id is not None else ''
 2854        '''
 2855         Unique identifier of the Resource.
 2856        '''
 2857        self.name = name if name is not None else ''
 2858        '''
 2859         Unique human-readable name of the Resource.
 2860        '''
 2861        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2862        '''
 2863         ID of the secret store containing credentials for this resource, if any.
 2864        '''
 2865        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2866        '''
 2867         Tags is a map of key, value pairs.
 2868        '''
 2869        self.tenant_id = tenant_id if tenant_id is not None else ''
 2870        '''
 2871
 2872        '''
 2873
 2874    def __repr__(self):
 2875        return '<sdm.AzureCertificate ' + \
 2876            'app_id: ' + repr(self.app_id) + ' ' +\
 2877            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2878            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 2879            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2880            'healthy: ' + repr(self.healthy) + ' ' +\
 2881            'id: ' + repr(self.id) + ' ' +\
 2882            'name: ' + repr(self.name) + ' ' +\
 2883            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2884            'tags: ' + repr(self.tags) + ' ' +\
 2885            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
 2886            '>'
 2887
 2888    def to_dict(self):
 2889        return {
 2890            'app_id': self.app_id,
 2891            'bind_interface': self.bind_interface,
 2892            'client_certificate': self.client_certificate,
 2893            'egress_filter': self.egress_filter,
 2894            'healthy': self.healthy,
 2895            'id': self.id,
 2896            'name': self.name,
 2897            'secret_store_id': self.secret_store_id,
 2898            'tags': self.tags,
 2899            'tenant_id': self.tenant_id,
 2900        }
 2901
 2902    @classmethod
 2903    def from_dict(cls, d):
 2904        return cls(
 2905            app_id=d.get('app_id'),
 2906            bind_interface=d.get('bind_interface'),
 2907            client_certificate=d.get('client_certificate'),
 2908            egress_filter=d.get('egress_filter'),
 2909            healthy=d.get('healthy'),
 2910            id=d.get('id'),
 2911            name=d.get('name'),
 2912            secret_store_id=d.get('secret_store_id'),
 2913            tags=d.get('tags'),
 2914            tenant_id=d.get('tenant_id'),
 2915        )
 2916
 2917
 2918class AzurePostgres:
 2919    '''
 2920
 2921    '''
 2922    __slots__ = [
 2923        'bind_interface',
 2924        'database',
 2925        'egress_filter',
 2926        'healthy',
 2927        'hostname',
 2928        'id',
 2929        'name',
 2930        'override_database',
 2931        'password',
 2932        'port',
 2933        'port_override',
 2934        'secret_store_id',
 2935        'tags',
 2936        'username',
 2937    ]
 2938
 2939    def __init__(
 2940        self,
 2941        bind_interface=None,
 2942        database=None,
 2943        egress_filter=None,
 2944        healthy=None,
 2945        hostname=None,
 2946        id=None,
 2947        name=None,
 2948        override_database=None,
 2949        password=None,
 2950        port=None,
 2951        port_override=None,
 2952        secret_store_id=None,
 2953        tags=None,
 2954        username=None,
 2955    ):
 2956        self.bind_interface = bind_interface if bind_interface is not None else ''
 2957        '''
 2958         Bind interface
 2959        '''
 2960        self.database = database if database is not None else ''
 2961        '''
 2962
 2963        '''
 2964        self.egress_filter = egress_filter if egress_filter is not None else ''
 2965        '''
 2966         A filter applied to the routing logic to pin datasource to nodes.
 2967        '''
 2968        self.healthy = healthy if healthy is not None else False
 2969        '''
 2970         True if the datasource is reachable and the credentials are valid.
 2971        '''
 2972        self.hostname = hostname if hostname is not None else ''
 2973        '''
 2974
 2975        '''
 2976        self.id = id if id is not None else ''
 2977        '''
 2978         Unique identifier of the Resource.
 2979        '''
 2980        self.name = name if name is not None else ''
 2981        '''
 2982         Unique human-readable name of the Resource.
 2983        '''
 2984        self.override_database = override_database if override_database is not None else False
 2985        '''
 2986
 2987        '''
 2988        self.password = password if password is not None else ''
 2989        '''
 2990
 2991        '''
 2992        self.port = port if port is not None else 0
 2993        '''
 2994
 2995        '''
 2996        self.port_override = port_override if port_override is not None else 0
 2997        '''
 2998
 2999        '''
 3000        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3001        '''
 3002         ID of the secret store containing credentials for this resource, if any.
 3003        '''
 3004        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3005        '''
 3006         Tags is a map of key, value pairs.
 3007        '''
 3008        self.username = username if username is not None else ''
 3009        '''
 3010
 3011        '''
 3012
 3013    def __repr__(self):
 3014        return '<sdm.AzurePostgres ' + \
 3015            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3016            'database: ' + repr(self.database) + ' ' +\
 3017            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3018            'healthy: ' + repr(self.healthy) + ' ' +\
 3019            'hostname: ' + repr(self.hostname) + ' ' +\
 3020            'id: ' + repr(self.id) + ' ' +\
 3021            'name: ' + repr(self.name) + ' ' +\
 3022            'override_database: ' + repr(self.override_database) + ' ' +\
 3023            'password: ' + repr(self.password) + ' ' +\
 3024            'port: ' + repr(self.port) + ' ' +\
 3025            'port_override: ' + repr(self.port_override) + ' ' +\
 3026            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3027            'tags: ' + repr(self.tags) + ' ' +\
 3028            'username: ' + repr(self.username) + ' ' +\
 3029            '>'
 3030
 3031    def to_dict(self):
 3032        return {
 3033            'bind_interface': self.bind_interface,
 3034            'database': self.database,
 3035            'egress_filter': self.egress_filter,
 3036            'healthy': self.healthy,
 3037            'hostname': self.hostname,
 3038            'id': self.id,
 3039            'name': self.name,
 3040            'override_database': self.override_database,
 3041            'password': self.password,
 3042            'port': self.port,
 3043            'port_override': self.port_override,
 3044            'secret_store_id': self.secret_store_id,
 3045            'tags': self.tags,
 3046            'username': self.username,
 3047        }
 3048
 3049    @classmethod
 3050    def from_dict(cls, d):
 3051        return cls(
 3052            bind_interface=d.get('bind_interface'),
 3053            database=d.get('database'),
 3054            egress_filter=d.get('egress_filter'),
 3055            healthy=d.get('healthy'),
 3056            hostname=d.get('hostname'),
 3057            id=d.get('id'),
 3058            name=d.get('name'),
 3059            override_database=d.get('override_database'),
 3060            password=d.get('password'),
 3061            port=d.get('port'),
 3062            port_override=d.get('port_override'),
 3063            secret_store_id=d.get('secret_store_id'),
 3064            tags=d.get('tags'),
 3065            username=d.get('username'),
 3066        )
 3067
 3068
 3069class AzureStore:
 3070    '''
 3071
 3072    '''
 3073    __slots__ = [
 3074        'id',
 3075        'name',
 3076        'tags',
 3077        'vault_uri',
 3078    ]
 3079
 3080    def __init__(
 3081        self,
 3082        id=None,
 3083        name=None,
 3084        tags=None,
 3085        vault_uri=None,
 3086    ):
 3087        self.id = id if id is not None else ''
 3088        '''
 3089         Unique identifier of the SecretStore.
 3090        '''
 3091        self.name = name if name is not None else ''
 3092        '''
 3093         Unique human-readable name of the SecretStore.
 3094        '''
 3095        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3096        '''
 3097         Tags is a map of key, value pairs.
 3098        '''
 3099        self.vault_uri = vault_uri if vault_uri is not None else ''
 3100        '''
 3101
 3102        '''
 3103
 3104    def __repr__(self):
 3105        return '<sdm.AzureStore ' + \
 3106            'id: ' + repr(self.id) + ' ' +\
 3107            'name: ' + repr(self.name) + ' ' +\
 3108            'tags: ' + repr(self.tags) + ' ' +\
 3109            'vault_uri: ' + repr(self.vault_uri) + ' ' +\
 3110            '>'
 3111
 3112    def to_dict(self):
 3113        return {
 3114            'id': self.id,
 3115            'name': self.name,
 3116            'tags': self.tags,
 3117            'vault_uri': self.vault_uri,
 3118        }
 3119
 3120    @classmethod
 3121    def from_dict(cls, d):
 3122        return cls(
 3123            id=d.get('id'),
 3124            name=d.get('name'),
 3125            tags=d.get('tags'),
 3126            vault_uri=d.get('vault_uri'),
 3127        )
 3128
 3129
 3130class BigQuery:
 3131    '''
 3132
 3133    '''
 3134    __slots__ = [
 3135        'bind_interface',
 3136        'egress_filter',
 3137        'endpoint',
 3138        'healthy',
 3139        'id',
 3140        'name',
 3141        'port_override',
 3142        'private_key',
 3143        'project',
 3144        'secret_store_id',
 3145        'tags',
 3146        'username',
 3147    ]
 3148
 3149    def __init__(
 3150        self,
 3151        bind_interface=None,
 3152        egress_filter=None,
 3153        endpoint=None,
 3154        healthy=None,
 3155        id=None,
 3156        name=None,
 3157        port_override=None,
 3158        private_key=None,
 3159        project=None,
 3160        secret_store_id=None,
 3161        tags=None,
 3162        username=None,
 3163    ):
 3164        self.bind_interface = bind_interface if bind_interface is not None else ''
 3165        '''
 3166         Bind interface
 3167        '''
 3168        self.egress_filter = egress_filter if egress_filter is not None else ''
 3169        '''
 3170         A filter applied to the routing logic to pin datasource to nodes.
 3171        '''
 3172        self.endpoint = endpoint if endpoint is not None else ''
 3173        '''
 3174
 3175        '''
 3176        self.healthy = healthy if healthy is not None else False
 3177        '''
 3178         True if the datasource is reachable and the credentials are valid.
 3179        '''
 3180        self.id = id if id is not None else ''
 3181        '''
 3182         Unique identifier of the Resource.
 3183        '''
 3184        self.name = name if name is not None else ''
 3185        '''
 3186         Unique human-readable name of the Resource.
 3187        '''
 3188        self.port_override = port_override if port_override is not None else 0
 3189        '''
 3190
 3191        '''
 3192        self.private_key = private_key if private_key is not None else ''
 3193        '''
 3194
 3195        '''
 3196        self.project = project if project is not None else ''
 3197        '''
 3198
 3199        '''
 3200        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3201        '''
 3202         ID of the secret store containing credentials for this resource, if any.
 3203        '''
 3204        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3205        '''
 3206         Tags is a map of key, value pairs.
 3207        '''
 3208        self.username = username if username is not None else ''
 3209        '''
 3210
 3211        '''
 3212
 3213    def __repr__(self):
 3214        return '<sdm.BigQuery ' + \
 3215            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3216            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3217            'endpoint: ' + repr(self.endpoint) + ' ' +\
 3218            'healthy: ' + repr(self.healthy) + ' ' +\
 3219            'id: ' + repr(self.id) + ' ' +\
 3220            'name: ' + repr(self.name) + ' ' +\
 3221            'port_override: ' + repr(self.port_override) + ' ' +\
 3222            'private_key: ' + repr(self.private_key) + ' ' +\
 3223            'project: ' + repr(self.project) + ' ' +\
 3224            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3225            'tags: ' + repr(self.tags) + ' ' +\
 3226            'username: ' + repr(self.username) + ' ' +\
 3227            '>'
 3228
 3229    def to_dict(self):
 3230        return {
 3231            'bind_interface': self.bind_interface,
 3232            'egress_filter': self.egress_filter,
 3233            'endpoint': self.endpoint,
 3234            'healthy': self.healthy,
 3235            'id': self.id,
 3236            'name': self.name,
 3237            'port_override': self.port_override,
 3238            'private_key': self.private_key,
 3239            'project': self.project,
 3240            'secret_store_id': self.secret_store_id,
 3241            'tags': self.tags,
 3242            'username': self.username,
 3243        }
 3244
 3245    @classmethod
 3246    def from_dict(cls, d):
 3247        return cls(
 3248            bind_interface=d.get('bind_interface'),
 3249            egress_filter=d.get('egress_filter'),
 3250            endpoint=d.get('endpoint'),
 3251            healthy=d.get('healthy'),
 3252            id=d.get('id'),
 3253            name=d.get('name'),
 3254            port_override=d.get('port_override'),
 3255            private_key=d.get('private_key'),
 3256            project=d.get('project'),
 3257            secret_store_id=d.get('secret_store_id'),
 3258            tags=d.get('tags'),
 3259            username=d.get('username'),
 3260        )
 3261
 3262
 3263class Cassandra:
 3264    '''
 3265
 3266    '''
 3267    __slots__ = [
 3268        'bind_interface',
 3269        'egress_filter',
 3270        'healthy',
 3271        'hostname',
 3272        'id',
 3273        'name',
 3274        'password',
 3275        'port',
 3276        'port_override',
 3277        'secret_store_id',
 3278        'tags',
 3279        'tls_required',
 3280        'username',
 3281    ]
 3282
 3283    def __init__(
 3284        self,
 3285        bind_interface=None,
 3286        egress_filter=None,
 3287        healthy=None,
 3288        hostname=None,
 3289        id=None,
 3290        name=None,
 3291        password=None,
 3292        port=None,
 3293        port_override=None,
 3294        secret_store_id=None,
 3295        tags=None,
 3296        tls_required=None,
 3297        username=None,
 3298    ):
 3299        self.bind_interface = bind_interface if bind_interface is not None else ''
 3300        '''
 3301         Bind interface
 3302        '''
 3303        self.egress_filter = egress_filter if egress_filter is not None else ''
 3304        '''
 3305         A filter applied to the routing logic to pin datasource to nodes.
 3306        '''
 3307        self.healthy = healthy if healthy is not None else False
 3308        '''
 3309         True if the datasource is reachable and the credentials are valid.
 3310        '''
 3311        self.hostname = hostname if hostname is not None else ''
 3312        '''
 3313
 3314        '''
 3315        self.id = id if id is not None else ''
 3316        '''
 3317         Unique identifier of the Resource.
 3318        '''
 3319        self.name = name if name is not None else ''
 3320        '''
 3321         Unique human-readable name of the Resource.
 3322        '''
 3323        self.password = password if password is not None else ''
 3324        '''
 3325
 3326        '''
 3327        self.port = port if port is not None else 0
 3328        '''
 3329
 3330        '''
 3331        self.port_override = port_override if port_override is not None else 0
 3332        '''
 3333
 3334        '''
 3335        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3336        '''
 3337         ID of the secret store containing credentials for this resource, if any.
 3338        '''
 3339        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3340        '''
 3341         Tags is a map of key, value pairs.
 3342        '''
 3343        self.tls_required = tls_required if tls_required is not None else False
 3344        '''
 3345
 3346        '''
 3347        self.username = username if username is not None else ''
 3348        '''
 3349
 3350        '''
 3351
 3352    def __repr__(self):
 3353        return '<sdm.Cassandra ' + \
 3354            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3355            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3356            'healthy: ' + repr(self.healthy) + ' ' +\
 3357            'hostname: ' + repr(self.hostname) + ' ' +\
 3358            'id: ' + repr(self.id) + ' ' +\
 3359            'name: ' + repr(self.name) + ' ' +\
 3360            'password: ' + repr(self.password) + ' ' +\
 3361            'port: ' + repr(self.port) + ' ' +\
 3362            'port_override: ' + repr(self.port_override) + ' ' +\
 3363            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3364            'tags: ' + repr(self.tags) + ' ' +\
 3365            'tls_required: ' + repr(self.tls_required) + ' ' +\
 3366            'username: ' + repr(self.username) + ' ' +\
 3367            '>'
 3368
 3369    def to_dict(self):
 3370        return {
 3371            'bind_interface': self.bind_interface,
 3372            'egress_filter': self.egress_filter,
 3373            'healthy': self.healthy,
 3374            'hostname': self.hostname,
 3375            'id': self.id,
 3376            'name': self.name,
 3377            'password': self.password,
 3378            'port': self.port,
 3379            'port_override': self.port_override,
 3380            'secret_store_id': self.secret_store_id,
 3381            'tags': self.tags,
 3382            'tls_required': self.tls_required,
 3383            'username': self.username,
 3384        }
 3385
 3386    @classmethod
 3387    def from_dict(cls, d):
 3388        return cls(
 3389            bind_interface=d.get('bind_interface'),
 3390            egress_filter=d.get('egress_filter'),
 3391            healthy=d.get('healthy'),
 3392            hostname=d.get('hostname'),
 3393            id=d.get('id'),
 3394            name=d.get('name'),
 3395            password=d.get('password'),
 3396            port=d.get('port'),
 3397            port_override=d.get('port_override'),
 3398            secret_store_id=d.get('secret_store_id'),
 3399            tags=d.get('tags'),
 3400            tls_required=d.get('tls_required'),
 3401            username=d.get('username'),
 3402        )
 3403
 3404
 3405class Citus:
 3406    '''
 3407
 3408    '''
 3409    __slots__ = [
 3410        'bind_interface',
 3411        'database',
 3412        'egress_filter',
 3413        'healthy',
 3414        'hostname',
 3415        'id',
 3416        'name',
 3417        'override_database',
 3418        'password',
 3419        'port',
 3420        'port_override',
 3421        'secret_store_id',
 3422        'tags',
 3423        'username',
 3424    ]
 3425
 3426    def __init__(
 3427        self,
 3428        bind_interface=None,
 3429        database=None,
 3430        egress_filter=None,
 3431        healthy=None,
 3432        hostname=None,
 3433        id=None,
 3434        name=None,
 3435        override_database=None,
 3436        password=None,
 3437        port=None,
 3438        port_override=None,
 3439        secret_store_id=None,
 3440        tags=None,
 3441        username=None,
 3442    ):
 3443        self.bind_interface = bind_interface if bind_interface is not None else ''
 3444        '''
 3445         Bind interface
 3446        '''
 3447        self.database = database if database is not None else ''
 3448        '''
 3449
 3450        '''
 3451        self.egress_filter = egress_filter if egress_filter is not None else ''
 3452        '''
 3453         A filter applied to the routing logic to pin datasource to nodes.
 3454        '''
 3455        self.healthy = healthy if healthy is not None else False
 3456        '''
 3457         True if the datasource is reachable and the credentials are valid.
 3458        '''
 3459        self.hostname = hostname if hostname is not None else ''
 3460        '''
 3461
 3462        '''
 3463        self.id = id if id is not None else ''
 3464        '''
 3465         Unique identifier of the Resource.
 3466        '''
 3467        self.name = name if name is not None else ''
 3468        '''
 3469         Unique human-readable name of the Resource.
 3470        '''
 3471        self.override_database = override_database if override_database is not None else False
 3472        '''
 3473
 3474        '''
 3475        self.password = password if password is not None else ''
 3476        '''
 3477
 3478        '''
 3479        self.port = port if port is not None else 0
 3480        '''
 3481
 3482        '''
 3483        self.port_override = port_override if port_override is not None else 0
 3484        '''
 3485
 3486        '''
 3487        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3488        '''
 3489         ID of the secret store containing credentials for this resource, if any.
 3490        '''
 3491        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3492        '''
 3493         Tags is a map of key, value pairs.
 3494        '''
 3495        self.username = username if username is not None else ''
 3496        '''
 3497
 3498        '''
 3499
 3500    def __repr__(self):
 3501        return '<sdm.Citus ' + \
 3502            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3503            'database: ' + repr(self.database) + ' ' +\
 3504            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3505            'healthy: ' + repr(self.healthy) + ' ' +\
 3506            'hostname: ' + repr(self.hostname) + ' ' +\
 3507            'id: ' + repr(self.id) + ' ' +\
 3508            'name: ' + repr(self.name) + ' ' +\
 3509            'override_database: ' + repr(self.override_database) + ' ' +\
 3510            'password: ' + repr(self.password) + ' ' +\
 3511            'port: ' + repr(self.port) + ' ' +\
 3512            'port_override: ' + repr(self.port_override) + ' ' +\
 3513            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3514            'tags: ' + repr(self.tags) + ' ' +\
 3515            'username: ' + repr(self.username) + ' ' +\
 3516            '>'
 3517
 3518    def to_dict(self):
 3519        return {
 3520            'bind_interface': self.bind_interface,
 3521            'database': self.database,
 3522            'egress_filter': self.egress_filter,
 3523            'healthy': self.healthy,
 3524            'hostname': self.hostname,
 3525            'id': self.id,
 3526            'name': self.name,
 3527            'override_database': self.override_database,
 3528            'password': self.password,
 3529            'port': self.port,
 3530            'port_override': self.port_override,
 3531            'secret_store_id': self.secret_store_id,
 3532            'tags': self.tags,
 3533            'username': self.username,
 3534        }
 3535
 3536    @classmethod
 3537    def from_dict(cls, d):
 3538        return cls(
 3539            bind_interface=d.get('bind_interface'),
 3540            database=d.get('database'),
 3541            egress_filter=d.get('egress_filter'),
 3542            healthy=d.get('healthy'),
 3543            hostname=d.get('hostname'),
 3544            id=d.get('id'),
 3545            name=d.get('name'),
 3546            override_database=d.get('override_database'),
 3547            password=d.get('password'),
 3548            port=d.get('port'),
 3549            port_override=d.get('port_override'),
 3550            secret_store_id=d.get('secret_store_id'),
 3551            tags=d.get('tags'),
 3552            username=d.get('username'),
 3553        )
 3554
 3555
 3556class Clustrix:
 3557    '''
 3558
 3559    '''
 3560    __slots__ = [
 3561        'bind_interface',
 3562        'database',
 3563        'egress_filter',
 3564        'healthy',
 3565        'hostname',
 3566        'id',
 3567        'name',
 3568        'password',
 3569        'port',
 3570        'port_override',
 3571        'secret_store_id',
 3572        'tags',
 3573        'username',
 3574    ]
 3575
 3576    def __init__(
 3577        self,
 3578        bind_interface=None,
 3579        database=None,
 3580        egress_filter=None,
 3581        healthy=None,
 3582        hostname=None,
 3583        id=None,
 3584        name=None,
 3585        password=None,
 3586        port=None,
 3587        port_override=None,
 3588        secret_store_id=None,
 3589        tags=None,
 3590        username=None,
 3591    ):
 3592        self.bind_interface = bind_interface if bind_interface is not None else ''
 3593        '''
 3594         Bind interface
 3595        '''
 3596        self.database = database if database is not None else ''
 3597        '''
 3598
 3599        '''
 3600        self.egress_filter = egress_filter if egress_filter is not None else ''
 3601        '''
 3602         A filter applied to the routing logic to pin datasource to nodes.
 3603        '''
 3604        self.healthy = healthy if healthy is not None else False
 3605        '''
 3606         True if the datasource is reachable and the credentials are valid.
 3607        '''
 3608        self.hostname = hostname if hostname is not None else ''
 3609        '''
 3610
 3611        '''
 3612        self.id = id if id is not None else ''
 3613        '''
 3614         Unique identifier of the Resource.
 3615        '''
 3616        self.name = name if name is not None else ''
 3617        '''
 3618         Unique human-readable name of the Resource.
 3619        '''
 3620        self.password = password if password is not None else ''
 3621        '''
 3622
 3623        '''
 3624        self.port = port if port is not None else 0
 3625        '''
 3626
 3627        '''
 3628        self.port_override = port_override if port_override is not None else 0
 3629        '''
 3630
 3631        '''
 3632        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3633        '''
 3634         ID of the secret store containing credentials for this resource, if any.
 3635        '''
 3636        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3637        '''
 3638         Tags is a map of key, value pairs.
 3639        '''
 3640        self.username = username if username is not None else ''
 3641        '''
 3642
 3643        '''
 3644
 3645    def __repr__(self):
 3646        return '<sdm.Clustrix ' + \
 3647            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3648            'database: ' + repr(self.database) + ' ' +\
 3649            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3650            'healthy: ' + repr(self.healthy) + ' ' +\
 3651            'hostname: ' + repr(self.hostname) + ' ' +\
 3652            'id: ' + repr(self.id) + ' ' +\
 3653            'name: ' + repr(self.name) + ' ' +\
 3654            'password: ' + repr(self.password) + ' ' +\
 3655            'port: ' + repr(self.port) + ' ' +\
 3656            'port_override: ' + repr(self.port_override) + ' ' +\
 3657            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3658            'tags: ' + repr(self.tags) + ' ' +\
 3659            'username: ' + repr(self.username) + ' ' +\
 3660            '>'
 3661
 3662    def to_dict(self):
 3663        return {
 3664            'bind_interface': self.bind_interface,
 3665            'database': self.database,
 3666            'egress_filter': self.egress_filter,
 3667            'healthy': self.healthy,
 3668            'hostname': self.hostname,
 3669            'id': self.id,
 3670            'name': self.name,
 3671            'password': self.password,
 3672            'port': self.port,
 3673            'port_override': self.port_override,
 3674            'secret_store_id': self.secret_store_id,
 3675            'tags': self.tags,
 3676            'username': self.username,
 3677        }
 3678
 3679    @classmethod
 3680    def from_dict(cls, d):
 3681        return cls(
 3682            bind_interface=d.get('bind_interface'),
 3683            database=d.get('database'),
 3684            egress_filter=d.get('egress_filter'),
 3685            healthy=d.get('healthy'),
 3686            hostname=d.get('hostname'),
 3687            id=d.get('id'),
 3688            name=d.get('name'),
 3689            password=d.get('password'),
 3690            port=d.get('port'),
 3691            port_override=d.get('port_override'),
 3692            secret_store_id=d.get('secret_store_id'),
 3693            tags=d.get('tags'),
 3694            username=d.get('username'),
 3695        )
 3696
 3697
 3698class Cockroach:
 3699    '''
 3700
 3701    '''
 3702    __slots__ = [
 3703        'bind_interface',
 3704        'database',
 3705        'egress_filter',
 3706        'healthy',
 3707        'hostname',
 3708        'id',
 3709        'name',
 3710        'override_database',
 3711        'password',
 3712        'port',
 3713        'port_override',
 3714        'secret_store_id',
 3715        'tags',
 3716        'username',
 3717    ]
 3718
 3719    def __init__(
 3720        self,
 3721        bind_interface=None,
 3722        database=None,
 3723        egress_filter=None,
 3724        healthy=None,
 3725        hostname=None,
 3726        id=None,
 3727        name=None,
 3728        override_database=None,
 3729        password=None,
 3730        port=None,
 3731        port_override=None,
 3732        secret_store_id=None,
 3733        tags=None,
 3734        username=None,
 3735    ):
 3736        self.bind_interface = bind_interface if bind_interface is not None else ''
 3737        '''
 3738         Bind interface
 3739        '''
 3740        self.database = database if database is not None else ''
 3741        '''
 3742
 3743        '''
 3744        self.egress_filter = egress_filter if egress_filter is not None else ''
 3745        '''
 3746         A filter applied to the routing logic to pin datasource to nodes.
 3747        '''
 3748        self.healthy = healthy if healthy is not None else False
 3749        '''
 3750         True if the datasource is reachable and the credentials are valid.
 3751        '''
 3752        self.hostname = hostname if hostname is not None else ''
 3753        '''
 3754
 3755        '''
 3756        self.id = id if id is not None else ''
 3757        '''
 3758         Unique identifier of the Resource.
 3759        '''
 3760        self.name = name if name is not None else ''
 3761        '''
 3762         Unique human-readable name of the Resource.
 3763        '''
 3764        self.override_database = override_database if override_database is not None else False
 3765        '''
 3766
 3767        '''
 3768        self.password = password if password is not None else ''
 3769        '''
 3770
 3771        '''
 3772        self.port = port if port is not None else 0
 3773        '''
 3774
 3775        '''
 3776        self.port_override = port_override if port_override is not None else 0
 3777        '''
 3778
 3779        '''
 3780        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3781        '''
 3782         ID of the secret store containing credentials for this resource, if any.
 3783        '''
 3784        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3785        '''
 3786         Tags is a map of key, value pairs.
 3787        '''
 3788        self.username = username if username is not None else ''
 3789        '''
 3790
 3791        '''
 3792
 3793    def __repr__(self):
 3794        return '<sdm.Cockroach ' + \
 3795            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3796            'database: ' + repr(self.database) + ' ' +\
 3797            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3798            'healthy: ' + repr(self.healthy) + ' ' +\
 3799            'hostname: ' + repr(self.hostname) + ' ' +\
 3800            'id: ' + repr(self.id) + ' ' +\
 3801            'name: ' + repr(self.name) + ' ' +\
 3802            'override_database: ' + repr(self.override_database) + ' ' +\
 3803            'password: ' + repr(self.password) + ' ' +\
 3804            'port: ' + repr(self.port) + ' ' +\
 3805            'port_override: ' + repr(self.port_override) + ' ' +\
 3806            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3807            'tags: ' + repr(self.tags) + ' ' +\
 3808            'username: ' + repr(self.username) + ' ' +\
 3809            '>'
 3810
 3811    def to_dict(self):
 3812        return {
 3813            'bind_interface': self.bind_interface,
 3814            'database': self.database,
 3815            'egress_filter': self.egress_filter,
 3816            'healthy': self.healthy,
 3817            'hostname': self.hostname,
 3818            'id': self.id,
 3819            'name': self.name,
 3820            'override_database': self.override_database,
 3821            'password': self.password,
 3822            'port': self.port,
 3823            'port_override': self.port_override,
 3824            'secret_store_id': self.secret_store_id,
 3825            'tags': self.tags,
 3826            'username': self.username,
 3827        }
 3828
 3829    @classmethod
 3830    def from_dict(cls, d):
 3831        return cls(
 3832            bind_interface=d.get('bind_interface'),
 3833            database=d.get('database'),
 3834            egress_filter=d.get('egress_filter'),
 3835            healthy=d.get('healthy'),
 3836            hostname=d.get('hostname'),
 3837            id=d.get('id'),
 3838            name=d.get('name'),
 3839            override_database=d.get('override_database'),
 3840            password=d.get('password'),
 3841            port=d.get('port'),
 3842            port_override=d.get('port_override'),
 3843            secret_store_id=d.get('secret_store_id'),
 3844            tags=d.get('tags'),
 3845            username=d.get('username'),
 3846        )
 3847
 3848
 3849class ControlPanelGetSSHCAPublicKeyResponse:
 3850    '''
 3851     ControlPanelGetSSHCAPublicKeyResponse represents a request for an
 3852     organization's SSH Certificate Authority public key.
 3853    '''
 3854    __slots__ = [
 3855        'meta',
 3856        'public_key',
 3857        'rate_limit',
 3858    ]
 3859
 3860    def __init__(
 3861        self,
 3862        meta=None,
 3863        public_key=None,
 3864        rate_limit=None,
 3865    ):
 3866        self.meta = meta if meta is not None else None
 3867        '''
 3868         Reserved for future use.
 3869        '''
 3870        self.public_key = public_key if public_key is not None else ''
 3871        '''
 3872         The public key of the SSH Certificate Authority, in OpenSSH RSA public
 3873         key format.
 3874        '''
 3875        self.rate_limit = rate_limit if rate_limit is not None else None
 3876        '''
 3877         Rate limit information.
 3878        '''
 3879
 3880    def __repr__(self):
 3881        return '<sdm.ControlPanelGetSSHCAPublicKeyResponse ' + \
 3882            'meta: ' + repr(self.meta) + ' ' +\
 3883            'public_key: ' + repr(self.public_key) + ' ' +\
 3884            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 3885            '>'
 3886
 3887    def to_dict(self):
 3888        return {
 3889            'meta': self.meta,
 3890            'public_key': self.public_key,
 3891            'rate_limit': self.rate_limit,
 3892        }
 3893
 3894    @classmethod
 3895    def from_dict(cls, d):
 3896        return cls(
 3897            meta=d.get('meta'),
 3898            public_key=d.get('public_key'),
 3899            rate_limit=d.get('rate_limit'),
 3900        )
 3901
 3902
 3903class ControlPanelVerifyJWTResponse:
 3904    '''
 3905     ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.
 3906    '''
 3907    __slots__ = [
 3908        'meta',
 3909        'rate_limit',
 3910        'valid',
 3911    ]
 3912
 3913    def __init__(
 3914        self,
 3915        meta=None,
 3916        rate_limit=None,
 3917        valid=None,
 3918    ):
 3919        self.meta = meta if meta is not None else None
 3920        '''
 3921         Reserved for future use.
 3922        '''
 3923        self.rate_limit = rate_limit if rate_limit is not None else None
 3924        '''
 3925         Rate limit information.
 3926        '''
 3927        self.valid = valid if valid is not None else False
 3928        '''
 3929         Reports if the given token is valid.
 3930        '''
 3931
 3932    def __repr__(self):
 3933        return '<sdm.ControlPanelVerifyJWTResponse ' + \
 3934            'meta: ' + repr(self.meta) + ' ' +\
 3935            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 3936            'valid: ' + repr(self.valid) + ' ' +\
 3937            '>'
 3938
 3939    def to_dict(self):
 3940        return {
 3941            'meta': self.meta,
 3942            'rate_limit': self.rate_limit,
 3943            'valid': self.valid,
 3944        }
 3945
 3946    @classmethod
 3947    def from_dict(cls, d):
 3948        return cls(
 3949            meta=d.get('meta'),
 3950            rate_limit=d.get('rate_limit'),
 3951            valid=d.get('valid'),
 3952        )
 3953
 3954
 3955class CreateResponseMetadata:
 3956    '''
 3957     CreateResponseMetadata is reserved for future use.
 3958    '''
 3959    __slots__ = []
 3960
 3961    def __init__(self, ):
 3962        pass
 3963
 3964    def __repr__(self):
 3965        return '<sdm.CreateResponseMetadata ' + \
 3966            '>'
 3967
 3968    def to_dict(self):
 3969        return {}
 3970
 3971    @classmethod
 3972    def from_dict(cls, d):
 3973        return cls()
 3974
 3975
 3976class DB2I:
 3977    '''
 3978
 3979    '''
 3980    __slots__ = [
 3981        'bind_interface',
 3982        'egress_filter',
 3983        'healthy',
 3984        'hostname',
 3985        'id',
 3986        'name',
 3987        'password',
 3988        'port',
 3989        'port_override',
 3990        'secret_store_id',
 3991        'tags',
 3992        'tls_required',
 3993        'username',
 3994    ]
 3995
 3996    def __init__(
 3997        self,
 3998        bind_interface=None,
 3999        egress_filter=None,
 4000        healthy=None,
 4001        hostname=None,
 4002        id=None,
 4003        name=None,
 4004        password=None,
 4005        port=None,
 4006        port_override=None,
 4007        secret_store_id=None,
 4008        tags=None,
 4009        tls_required=None,
 4010        username=None,
 4011    ):
 4012        self.bind_interface = bind_interface if bind_interface is not None else ''
 4013        '''
 4014         Bind interface
 4015        '''
 4016        self.egress_filter = egress_filter if egress_filter is not None else ''
 4017        '''
 4018         A filter applied to the routing logic to pin datasource to nodes.
 4019        '''
 4020        self.healthy = healthy if healthy is not None else False
 4021        '''
 4022         True if the datasource is reachable and the credentials are valid.
 4023        '''
 4024        self.hostname = hostname if hostname is not None else ''
 4025        '''
 4026
 4027        '''
 4028        self.id = id if id is not None else ''
 4029        '''
 4030         Unique identifier of the Resource.
 4031        '''
 4032        self.name = name if name is not None else ''
 4033        '''
 4034         Unique human-readable name of the Resource.
 4035        '''
 4036        self.password = password if password is not None else ''
 4037        '''
 4038
 4039        '''
 4040        self.port = port if port is not None else 0
 4041        '''
 4042
 4043        '''
 4044        self.port_override = port_override if port_override is not None else 0
 4045        '''
 4046
 4047        '''
 4048        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4049        '''
 4050         ID of the secret store containing credentials for this resource, if any.
 4051        '''
 4052        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4053        '''
 4054         Tags is a map of key, value pairs.
 4055        '''
 4056        self.tls_required = tls_required if tls_required is not None else False
 4057        '''
 4058
 4059        '''
 4060        self.username = username if username is not None else ''
 4061        '''
 4062
 4063        '''
 4064
 4065    def __repr__(self):
 4066        return '<sdm.DB2I ' + \
 4067            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4068            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4069            'healthy: ' + repr(self.healthy) + ' ' +\
 4070            'hostname: ' + repr(self.hostname) + ' ' +\
 4071            'id: ' + repr(self.id) + ' ' +\
 4072            'name: ' + repr(self.name) + ' ' +\
 4073            'password: ' + repr(self.password) + ' ' +\
 4074            'port: ' + repr(self.port) + ' ' +\
 4075            'port_override: ' + repr(self.port_override) + ' ' +\
 4076            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4077            'tags: ' + repr(self.tags) + ' ' +\
 4078            'tls_required: ' + repr(self.tls_required) + ' ' +\
 4079            'username: ' + repr(self.username) + ' ' +\
 4080            '>'
 4081
 4082    def to_dict(self):
 4083        return {
 4084            'bind_interface': self.bind_interface,
 4085            'egress_filter': self.egress_filter,
 4086            'healthy': self.healthy,
 4087            'hostname': self.hostname,
 4088            'id': self.id,
 4089            'name': self.name,
 4090            'password': self.password,
 4091            'port': self.port,
 4092            'port_override': self.port_override,
 4093            'secret_store_id': self.secret_store_id,
 4094            'tags': self.tags,
 4095            'tls_required': self.tls_required,
 4096            'username': self.username,
 4097        }
 4098
 4099    @classmethod
 4100    def from_dict(cls, d):
 4101        return cls(
 4102            bind_interface=d.get('bind_interface'),
 4103            egress_filter=d.get('egress_filter'),
 4104            healthy=d.get('healthy'),
 4105            hostname=d.get('hostname'),
 4106            id=d.get('id'),
 4107            name=d.get('name'),
 4108            password=d.get('password'),
 4109            port=d.get('port'),
 4110            port_override=d.get('port_override'),
 4111            secret_store_id=d.get('secret_store_id'),
 4112            tags=d.get('tags'),
 4113            tls_required=d.get('tls_required'),
 4114            username=d.get('username'),
 4115        )
 4116
 4117
 4118class DB2LUW:
 4119    '''
 4120
 4121    '''
 4122    __slots__ = [
 4123        'bind_interface',
 4124        'database',
 4125        'egress_filter',
 4126        'healthy',
 4127        'hostname',
 4128        'id',
 4129        'name',
 4130        'password',
 4131        'port',
 4132        'port_override',
 4133        'secret_store_id',
 4134        'tags',
 4135        'username',
 4136    ]
 4137
 4138    def __init__(
 4139        self,
 4140        bind_interface=None,
 4141        database=None,
 4142        egress_filter=None,
 4143        healthy=None,
 4144        hostname=None,
 4145        id=None,
 4146        name=None,
 4147        password=None,
 4148        port=None,
 4149        port_override=None,
 4150        secret_store_id=None,
 4151        tags=None,
 4152        username=None,
 4153    ):
 4154        self.bind_interface = bind_interface if bind_interface is not None else ''
 4155        '''
 4156         Bind interface
 4157        '''
 4158        self.database = database if database is not None else ''
 4159        '''
 4160
 4161        '''
 4162        self.egress_filter = egress_filter if egress_filter is not None else ''
 4163        '''
 4164         A filter applied to the routing logic to pin datasource to nodes.
 4165        '''
 4166        self.healthy = healthy if healthy is not None else False
 4167        '''
 4168         True if the datasource is reachable and the credentials are valid.
 4169        '''
 4170        self.hostname = hostname if hostname is not None else ''
 4171        '''
 4172
 4173        '''
 4174        self.id = id if id is not None else ''
 4175        '''
 4176         Unique identifier of the Resource.
 4177        '''
 4178        self.name = name if name is not None else ''
 4179        '''
 4180         Unique human-readable name of the Resource.
 4181        '''
 4182        self.password = password if password is not None else ''
 4183        '''
 4184
 4185        '''
 4186        self.port = port if port is not None else 0
 4187        '''
 4188
 4189        '''
 4190        self.port_override = port_override if port_override is not None else 0
 4191        '''
 4192
 4193        '''
 4194        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4195        '''
 4196         ID of the secret store containing credentials for this resource, if any.
 4197        '''
 4198        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4199        '''
 4200         Tags is a map of key, value pairs.
 4201        '''
 4202        self.username = username if username is not None else ''
 4203        '''
 4204
 4205        '''
 4206
 4207    def __repr__(self):
 4208        return '<sdm.DB2LUW ' + \
 4209            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4210            'database: ' + repr(self.database) + ' ' +\
 4211            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4212            'healthy: ' + repr(self.healthy) + ' ' +\
 4213            'hostname: ' + repr(self.hostname) + ' ' +\
 4214            'id: ' + repr(self.id) + ' ' +\
 4215            'name: ' + repr(self.name) + ' ' +\
 4216            'password: ' + repr(self.password) + ' ' +\
 4217            'port: ' + repr(self.port) + ' ' +\
 4218            'port_override: ' + repr(self.port_override) + ' ' +\
 4219            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4220            'tags: ' + repr(self.tags) + ' ' +\
 4221            'username: ' + repr(self.username) + ' ' +\
 4222            '>'
 4223
 4224    def to_dict(self):
 4225        return {
 4226            'bind_interface': self.bind_interface,
 4227            'database': self.database,
 4228            'egress_filter': self.egress_filter,
 4229            'healthy': self.healthy,
 4230            'hostname': self.hostname,
 4231            'id': self.id,
 4232            'name': self.name,
 4233            'password': self.password,
 4234            'port': self.port,
 4235            'port_override': self.port_override,
 4236            'secret_store_id': self.secret_store_id,
 4237            'tags': self.tags,
 4238            'username': self.username,
 4239        }
 4240
 4241    @classmethod
 4242    def from_dict(cls, d):
 4243        return cls(
 4244            bind_interface=d.get('bind_interface'),
 4245            database=d.get('database'),
 4246            egress_filter=d.get('egress_filter'),
 4247            healthy=d.get('healthy'),
 4248            hostname=d.get('hostname'),
 4249            id=d.get('id'),
 4250            name=d.get('name'),
 4251            password=d.get('password'),
 4252            port=d.get('port'),
 4253            port_override=d.get('port_override'),
 4254            secret_store_id=d.get('secret_store_id'),
 4255            tags=d.get('tags'),
 4256            username=d.get('username'),
 4257        )
 4258
 4259
 4260class DeleteResponseMetadata:
 4261    '''
 4262     DeleteResponseMetadata is reserved for future use.
 4263    '''
 4264    __slots__ = []
 4265
 4266    def __init__(self, ):
 4267        pass
 4268
 4269    def __repr__(self):
 4270        return '<sdm.DeleteResponseMetadata ' + \
 4271            '>'
 4272
 4273    def to_dict(self):
 4274        return {}
 4275
 4276    @classmethod
 4277    def from_dict(cls, d):
 4278        return cls()
 4279
 4280
 4281class DocumentDBHost:
 4282    '''
 4283
 4284    '''
 4285    __slots__ = [
 4286        'auth_database',
 4287        'bind_interface',
 4288        'egress_filter',
 4289        'healthy',
 4290        'hostname',
 4291        'id',
 4292        'name',
 4293        'password',
 4294        'port',
 4295        'port_override',
 4296        'secret_store_id',
 4297        'tags',
 4298        'username',
 4299    ]
 4300
 4301    def __init__(
 4302        self,
 4303        auth_database=None,
 4304        bind_interface=None,
 4305        egress_filter=None,
 4306        healthy=None,
 4307        hostname=None,
 4308        id=None,
 4309        name=None,
 4310        password=None,
 4311        port=None,
 4312        port_override=None,
 4313        secret_store_id=None,
 4314        tags=None,
 4315        username=None,
 4316    ):
 4317        self.auth_database = auth_database if auth_database is not None else ''
 4318        '''
 4319
 4320        '''
 4321        self.bind_interface = bind_interface if bind_interface is not None else ''
 4322        '''
 4323         Bind interface
 4324        '''
 4325        self.egress_filter = egress_filter if egress_filter is not None else ''
 4326        '''
 4327         A filter applied to the routing logic to pin datasource to nodes.
 4328        '''
 4329        self.healthy = healthy if healthy is not None else False
 4330        '''
 4331         True if the datasource is reachable and the credentials are valid.
 4332        '''
 4333        self.hostname = hostname if hostname is not None else ''
 4334        '''
 4335
 4336        '''
 4337        self.id = id if id is not None else ''
 4338        '''
 4339         Unique identifier of the Resource.
 4340        '''
 4341        self.name = name if name is not None else ''
 4342        '''
 4343         Unique human-readable name of the Resource.
 4344        '''
 4345        self.password = password if password is not None else ''
 4346        '''
 4347
 4348        '''
 4349        self.port = port if port is not None else 0
 4350        '''
 4351
 4352        '''
 4353        self.port_override = port_override if port_override is not None else 0
 4354        '''
 4355
 4356        '''
 4357        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4358        '''
 4359         ID of the secret store containing credentials for this resource, if any.
 4360        '''
 4361        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4362        '''
 4363         Tags is a map of key, value pairs.
 4364        '''
 4365        self.username = username if username is not None else ''
 4366        '''
 4367
 4368        '''
 4369
 4370    def __repr__(self):
 4371        return '<sdm.DocumentDBHost ' + \
 4372            'auth_database: ' + repr(self.auth_database) + ' ' +\
 4373            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4374            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4375            'healthy: ' + repr(self.healthy) + ' ' +\
 4376            'hostname: ' + repr(self.hostname) + ' ' +\
 4377            'id: ' + repr(self.id) + ' ' +\
 4378            'name: ' + repr(self.name) + ' ' +\
 4379            'password: ' + repr(self.password) + ' ' +\
 4380            'port: ' + repr(self.port) + ' ' +\
 4381            'port_override: ' + repr(self.port_override) + ' ' +\
 4382            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4383            'tags: ' + repr(self.tags) + ' ' +\
 4384            'username: ' + repr(self.username) + ' ' +\
 4385            '>'
 4386
 4387    def to_dict(self):
 4388        return {
 4389            'auth_database': self.auth_database,
 4390            'bind_interface': self.bind_interface,
 4391            'egress_filter': self.egress_filter,
 4392            'healthy': self.healthy,
 4393            'hostname': self.hostname,
 4394            'id': self.id,
 4395            'name': self.name,
 4396            'password': self.password,
 4397            'port': self.port,
 4398            'port_override': self.port_override,
 4399            'secret_store_id': self.secret_store_id,
 4400            'tags': self.tags,
 4401            'username': self.username,
 4402        }
 4403
 4404    @classmethod
 4405    def from_dict(cls, d):
 4406        return cls(
 4407            auth_database=d.get('auth_database'),
 4408            bind_interface=d.get('bind_interface'),
 4409            egress_filter=d.get('egress_filter'),
 4410            healthy=d.get('healthy'),
 4411            hostname=d.get('hostname'),
 4412            id=d.get('id'),
 4413            name=d.get('name'),
 4414            password=d.get('password'),
 4415            port=d.get('port'),
 4416            port_override=d.get('port_override'),
 4417            secret_store_id=d.get('secret_store_id'),
 4418            tags=d.get('tags'),
 4419            username=d.get('username'),
 4420        )
 4421
 4422
 4423class DocumentDBReplicaSet:
 4424    '''
 4425
 4426    '''
 4427    __slots__ = [
 4428        'auth_database',
 4429        'bind_interface',
 4430        'connect_to_replica',
 4431        'egress_filter',
 4432        'healthy',
 4433        'hostname',
 4434        'id',
 4435        'name',
 4436        'password',
 4437        'port_override',
 4438        'replica_set',
 4439        'secret_store_id',
 4440        'tags',
 4441        'username',
 4442    ]
 4443
 4444    def __init__(
 4445        self,
 4446        auth_database=None,
 4447        bind_interface=None,
 4448        connect_to_replica=None,
 4449        egress_filter=None,
 4450        healthy=None,
 4451        hostname=None,
 4452        id=None,
 4453        name=None,
 4454        password=None,
 4455        port_override=None,
 4456        replica_set=None,
 4457        secret_store_id=None,
 4458        tags=None,
 4459        username=None,
 4460    ):
 4461        self.auth_database = auth_database if auth_database is not None else ''
 4462        '''
 4463
 4464        '''
 4465        self.bind_interface = bind_interface if bind_interface is not None else ''
 4466        '''
 4467         Bind interface
 4468        '''
 4469        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 4470        '''
 4471
 4472        '''
 4473        self.egress_filter = egress_filter if egress_filter is not None else ''
 4474        '''
 4475         A filter applied to the routing logic to pin datasource to nodes.
 4476        '''
 4477        self.healthy = healthy if healthy is not None else False
 4478        '''
 4479         True if the datasource is reachable and the credentials are valid.
 4480        '''
 4481        self.hostname = hostname if hostname is not None else ''
 4482        '''
 4483         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
 4484        '''
 4485        self.id = id if id is not None else ''
 4486        '''
 4487         Unique identifier of the Resource.
 4488        '''
 4489        self.name = name if name is not None else ''
 4490        '''
 4491         Unique human-readable name of the Resource.
 4492        '''
 4493        self.password = password if password is not None else ''
 4494        '''
 4495
 4496        '''
 4497        self.port_override = port_override if port_override is not None else 0
 4498        '''
 4499
 4500        '''
 4501        self.replica_set = replica_set if replica_set is not None else ''
 4502        '''
 4503
 4504        '''
 4505        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4506        '''
 4507         ID of the secret store containing credentials for this resource, if any.
 4508        '''
 4509        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4510        '''
 4511         Tags is a map of key, value pairs.
 4512        '''
 4513        self.username = username if username is not None else ''
 4514        '''
 4515
 4516        '''
 4517
 4518    def __repr__(self):
 4519        return '<sdm.DocumentDBReplicaSet ' + \
 4520            'auth_database: ' + repr(self.auth_database) + ' ' +\
 4521            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4522            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 4523            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4524            'healthy: ' + repr(self.healthy) + ' ' +\
 4525            'hostname: ' + repr(self.hostname) + ' ' +\
 4526            'id: ' + repr(self.id) + ' ' +\
 4527            'name: ' + repr(self.name) + ' ' +\
 4528            'password: ' + repr(self.password) + ' ' +\
 4529            'port_override: ' + repr(self.port_override) + ' ' +\
 4530            'replica_set: ' + repr(self.replica_set) + ' ' +\
 4531            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4532            'tags: ' + repr(self.tags) + ' ' +\
 4533            'username: ' + repr(self.username) + ' ' +\
 4534            '>'
 4535
 4536    def to_dict(self):
 4537        return {
 4538            'auth_database': self.auth_database,
 4539            'bind_interface': self.bind_interface,
 4540            'connect_to_replica': self.connect_to_replica,
 4541            'egress_filter': self.egress_filter,
 4542            'healthy': self.healthy,
 4543            'hostname': self.hostname,
 4544            'id': self.id,
 4545            'name': self.name,
 4546            'password': self.password,
 4547            'port_override': self.port_override,
 4548            'replica_set': self.replica_set,
 4549            'secret_store_id': self.secret_store_id,
 4550            'tags': self.tags,
 4551            'username': self.username,
 4552        }
 4553
 4554    @classmethod
 4555    def from_dict(cls, d):
 4556        return cls(
 4557            auth_database=d.get('auth_database'),
 4558            bind_interface=d.get('bind_interface'),
 4559            connect_to_replica=d.get('connect_to_replica'),
 4560            egress_filter=d.get('egress_filter'),
 4561            healthy=d.get('healthy'),
 4562            hostname=d.get('hostname'),
 4563            id=d.get('id'),
 4564            name=d.get('name'),
 4565            password=d.get('password'),
 4566            port_override=d.get('port_override'),
 4567            replica_set=d.get('replica_set'),
 4568            secret_store_id=d.get('secret_store_id'),
 4569            tags=d.get('tags'),
 4570            username=d.get('username'),
 4571        )
 4572
 4573
 4574class Druid:
 4575    '''
 4576
 4577    '''
 4578    __slots__ = [
 4579        'bind_interface',
 4580        'egress_filter',
 4581        'healthy',
 4582        'hostname',
 4583        'id',
 4584        'name',
 4585        'password',
 4586        'port',
 4587        'port_override',
 4588        'secret_store_id',
 4589        'tags',
 4590        'username',
 4591    ]
 4592
 4593    def __init__(
 4594        self,
 4595        bind_interface=None,
 4596        egress_filter=None,
 4597        healthy=None,
 4598        hostname=None,
 4599        id=None,
 4600        name=None,
 4601        password=None,
 4602        port=None,
 4603        port_override=None,
 4604        secret_store_id=None,
 4605        tags=None,
 4606        username=None,
 4607    ):
 4608        self.bind_interface = bind_interface if bind_interface is not None else ''
 4609        '''
 4610         Bind interface
 4611        '''
 4612        self.egress_filter = egress_filter if egress_filter is not None else ''
 4613        '''
 4614         A filter applied to the routing logic to pin datasource to nodes.
 4615        '''
 4616        self.healthy = healthy if healthy is not None else False
 4617        '''
 4618         True if the datasource is reachable and the credentials are valid.
 4619        '''
 4620        self.hostname = hostname if hostname is not None else ''
 4621        '''
 4622
 4623        '''
 4624        self.id = id if id is not None else ''
 4625        '''
 4626         Unique identifier of the Resource.
 4627        '''
 4628        self.name = name if name is not None else ''
 4629        '''
 4630         Unique human-readable name of the Resource.
 4631        '''
 4632        self.password = password if password is not None else ''
 4633        '''
 4634
 4635        '''
 4636        self.port = port if port is not None else 0
 4637        '''
 4638
 4639        '''
 4640        self.port_override = port_override if port_override is not None else 0
 4641        '''
 4642
 4643        '''
 4644        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4645        '''
 4646         ID of the secret store containing credentials for this resource, if any.
 4647        '''
 4648        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4649        '''
 4650         Tags is a map of key, value pairs.
 4651        '''
 4652        self.username = username if username is not None else ''
 4653        '''
 4654
 4655        '''
 4656
 4657    def __repr__(self):
 4658        return '<sdm.Druid ' + \
 4659            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4660            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4661            'healthy: ' + repr(self.healthy) + ' ' +\
 4662            'hostname: ' + repr(self.hostname) + ' ' +\
 4663            'id: ' + repr(self.id) + ' ' +\
 4664            'name: ' + repr(self.name) + ' ' +\
 4665            'password: ' + repr(self.password) + ' ' +\
 4666            'port: ' + repr(self.port) + ' ' +\
 4667            'port_override: ' + repr(self.port_override) + ' ' +\
 4668            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4669            'tags: ' + repr(self.tags) + ' ' +\
 4670            'username: ' + repr(self.username) + ' ' +\
 4671            '>'
 4672
 4673    def to_dict(self):
 4674        return {
 4675            'bind_interface': self.bind_interface,
 4676            'egress_filter': self.egress_filter,
 4677            'healthy': self.healthy,
 4678            'hostname': self.hostname,
 4679            'id': self.id,
 4680            'name': self.name,
 4681            'password': self.password,
 4682            'port': self.port,
 4683            'port_override': self.port_override,
 4684            'secret_store_id': self.secret_store_id,
 4685            'tags': self.tags,
 4686            'username': self.username,
 4687        }
 4688
 4689    @classmethod
 4690    def from_dict(cls, d):
 4691        return cls(
 4692            bind_interface=d.get('bind_interface'),
 4693            egress_filter=d.get('egress_filter'),
 4694            healthy=d.get('healthy'),
 4695            hostname=d.get('hostname'),
 4696            id=d.get('id'),
 4697            name=d.get('name'),
 4698            password=d.get('password'),
 4699            port=d.get('port'),
 4700            port_override=d.get('port_override'),
 4701            secret_store_id=d.get('secret_store_id'),
 4702            tags=d.get('tags'),
 4703            username=d.get('username'),
 4704        )
 4705
 4706
 4707class DynamoDB:
 4708    '''
 4709
 4710    '''
 4711    __slots__ = [
 4712        'access_key',
 4713        'bind_interface',
 4714        'egress_filter',
 4715        'endpoint',
 4716        'healthy',
 4717        'id',
 4718        'name',
 4719        'port_override',
 4720        'region',
 4721        'role_arn',
 4722        'role_external_id',
 4723        'secret_access_key',
 4724        'secret_store_id',
 4725        'tags',
 4726    ]
 4727
 4728    def __init__(
 4729        self,
 4730        access_key=None,
 4731        bind_interface=None,
 4732        egress_filter=None,
 4733        endpoint=None,
 4734        healthy=None,
 4735        id=None,
 4736        name=None,
 4737        port_override=None,
 4738        region=None,
 4739        role_arn=None,
 4740        role_external_id=None,
 4741        secret_access_key=None,
 4742        secret_store_id=None,
 4743        tags=None,
 4744    ):
 4745        self.access_key = access_key if access_key is not None else ''
 4746        '''
 4747
 4748        '''
 4749        self.bind_interface = bind_interface if bind_interface is not None else ''
 4750        '''
 4751         Bind interface
 4752        '''
 4753        self.egress_filter = egress_filter if egress_filter is not None else ''
 4754        '''
 4755         A filter applied to the routing logic to pin datasource to nodes.
 4756        '''
 4757        self.endpoint = endpoint if endpoint is not None else ''
 4758        '''
 4759
 4760        '''
 4761        self.healthy = healthy if healthy is not None else False
 4762        '''
 4763         True if the datasource is reachable and the credentials are valid.
 4764        '''
 4765        self.id = id if id is not None else ''
 4766        '''
 4767         Unique identifier of the Resource.
 4768        '''
 4769        self.name = name if name is not None else ''
 4770        '''
 4771         Unique human-readable name of the Resource.
 4772        '''
 4773        self.port_override = port_override if port_override is not None else 0
 4774        '''
 4775
 4776        '''
 4777        self.region = region if region is not None else ''
 4778        '''
 4779
 4780        '''
 4781        self.role_arn = role_arn if role_arn is not None else ''
 4782        '''
 4783
 4784        '''
 4785        self.role_external_id = role_external_id if role_external_id is not None else ''
 4786        '''
 4787
 4788        '''
 4789        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 4790        '''
 4791
 4792        '''
 4793        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4794        '''
 4795         ID of the secret store containing credentials for this resource, if any.
 4796        '''
 4797        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4798        '''
 4799         Tags is a map of key, value pairs.
 4800        '''
 4801
 4802    def __repr__(self):
 4803        return '<sdm.DynamoDB ' + \
 4804            'access_key: ' + repr(self.access_key) + ' ' +\
 4805            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4806            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4807            'endpoint: ' + repr(self.endpoint) + ' ' +\
 4808            'healthy: ' + repr(self.healthy) + ' ' +\
 4809            'id: ' + repr(self.id) + ' ' +\
 4810            'name: ' + repr(self.name) + ' ' +\
 4811            'port_override: ' + repr(self.port_override) + ' ' +\
 4812            'region: ' + repr(self.region) + ' ' +\
 4813            'role_arn: ' + repr(self.role_arn) + ' ' +\
 4814            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 4815            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 4816            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4817            'tags: ' + repr(self.tags) + ' ' +\
 4818            '>'
 4819
 4820    def to_dict(self):
 4821        return {
 4822            'access_key': self.access_key,
 4823            'bind_interface': self.bind_interface,
 4824            'egress_filter': self.egress_filter,
 4825            'endpoint': self.endpoint,
 4826            'healthy': self.healthy,
 4827            'id': self.id,
 4828            'name': self.name,
 4829            'port_override': self.port_override,
 4830            'region': self.region,
 4831            'role_arn': self.role_arn,
 4832            'role_external_id': self.role_external_id,
 4833            'secret_access_key': self.secret_access_key,
 4834            'secret_store_id': self.secret_store_id,
 4835            'tags': self.tags,
 4836        }
 4837
 4838    @classmethod
 4839    def from_dict(cls, d):
 4840        return cls(
 4841            access_key=d.get('access_key'),
 4842            bind_interface=d.get('bind_interface'),
 4843            egress_filter=d.get('egress_filter'),
 4844            endpoint=d.get('endpoint'),
 4845            healthy=d.get('healthy'),
 4846            id=d.get('id'),
 4847            name=d.get('name'),
 4848            port_override=d.get('port_override'),
 4849            region=d.get('region'),
 4850            role_arn=d.get('role_arn'),
 4851            role_external_id=d.get('role_external_id'),
 4852            secret_access_key=d.get('secret_access_key'),
 4853            secret_store_id=d.get('secret_store_id'),
 4854            tags=d.get('tags'),
 4855        )
 4856
 4857
 4858class Elastic:
 4859    '''
 4860
 4861    '''
 4862    __slots__ = [
 4863        'bind_interface',
 4864        'egress_filter',
 4865        'healthy',
 4866        'hostname',
 4867        'id',
 4868        'name',
 4869        'password',
 4870        'port',
 4871        'port_override',
 4872        'secret_store_id',
 4873        'tags',
 4874        'tls_required',
 4875        'username',
 4876    ]
 4877
 4878    def __init__(
 4879        self,
 4880        bind_interface=None,
 4881        egress_filter=None,
 4882        healthy=None,
 4883        hostname=None,
 4884        id=None,
 4885        name=None,
 4886        password=None,
 4887        port=None,
 4888        port_override=None,
 4889        secret_store_id=None,
 4890        tags=None,
 4891        tls_required=None,
 4892        username=None,
 4893    ):
 4894        self.bind_interface = bind_interface if bind_interface is not None else ''
 4895        '''
 4896         Bind interface
 4897        '''
 4898        self.egress_filter = egress_filter if egress_filter is not None else ''
 4899        '''
 4900         A filter applied to the routing logic to pin datasource to nodes.
 4901        '''
 4902        self.healthy = healthy if healthy is not None else False
 4903        '''
 4904         True if the datasource is reachable and the credentials are valid.
 4905        '''
 4906        self.hostname = hostname if hostname is not None else ''
 4907        '''
 4908
 4909        '''
 4910        self.id = id if id is not None else ''
 4911        '''
 4912         Unique identifier of the Resource.
 4913        '''
 4914        self.name = name if name is not None else ''
 4915        '''
 4916         Unique human-readable name of the Resource.
 4917        '''
 4918        self.password = password if password is not None else ''
 4919        '''
 4920
 4921        '''
 4922        self.port = port if port is not None else 0
 4923        '''
 4924
 4925        '''
 4926        self.port_override = port_override if port_override is not None else 0
 4927        '''
 4928
 4929        '''
 4930        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4931        '''
 4932         ID of the secret store containing credentials for this resource, if any.
 4933        '''
 4934        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4935        '''
 4936         Tags is a map of key, value pairs.
 4937        '''
 4938        self.tls_required = tls_required if tls_required is not None else False
 4939        '''
 4940
 4941        '''
 4942        self.username = username if username is not None else ''
 4943        '''
 4944
 4945        '''
 4946
 4947    def __repr__(self):
 4948        return '<sdm.Elastic ' + \
 4949            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4950            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4951            'healthy: ' + repr(self.healthy) + ' ' +\
 4952            'hostname: ' + repr(self.hostname) + ' ' +\
 4953            'id: ' + repr(self.id) + ' ' +\
 4954            'name: ' + repr(self.name) + ' ' +\
 4955            'password: ' + repr(self.password) + ' ' +\
 4956            'port: ' + repr(self.port) + ' ' +\
 4957            'port_override: ' + repr(self.port_override) + ' ' +\
 4958            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4959            'tags: ' + repr(self.tags) + ' ' +\
 4960            'tls_required: ' + repr(self.tls_required) + ' ' +\
 4961            'username: ' + repr(self.username) + ' ' +\
 4962            '>'
 4963
 4964    def to_dict(self):
 4965        return {
 4966            'bind_interface': self.bind_interface,
 4967            'egress_filter': self.egress_filter,
 4968            'healthy': self.healthy,
 4969            'hostname': self.hostname,
 4970            'id': self.id,
 4971            'name': self.name,
 4972            'password': self.password,
 4973            'port': self.port,
 4974            'port_override': self.port_override,
 4975            'secret_store_id': self.secret_store_id,
 4976            'tags': self.tags,
 4977            'tls_required': self.tls_required,
 4978            'username': self.username,
 4979        }
 4980
 4981    @classmethod
 4982    def from_dict(cls, d):
 4983        return cls(
 4984            bind_interface=d.get('bind_interface'),
 4985            egress_filter=d.get('egress_filter'),
 4986            healthy=d.get('healthy'),
 4987            hostname=d.get('hostname'),
 4988            id=d.get('id'),
 4989            name=d.get('name'),
 4990            password=d.get('password'),
 4991            port=d.get('port'),
 4992            port_override=d.get('port_override'),
 4993            secret_store_id=d.get('secret_store_id'),
 4994            tags=d.get('tags'),
 4995            tls_required=d.get('tls_required'),
 4996            username=d.get('username'),
 4997        )
 4998
 4999
 5000class ElasticacheRedis:
 5001    '''
 5002
 5003    '''
 5004    __slots__ = [
 5005        'bind_interface',
 5006        'egress_filter',
 5007        'healthy',
 5008        'hostname',
 5009        'id',
 5010        'name',
 5011        'password',
 5012        'port',
 5013        'port_override',
 5014        'secret_store_id',
 5015        'tags',
 5016        'tls_required',
 5017    ]
 5018
 5019    def __init__(
 5020        self,
 5021        bind_interface=None,
 5022        egress_filter=None,
 5023        healthy=None,
 5024        hostname=None,
 5025        id=None,
 5026        name=None,
 5027        password=None,
 5028        port=None,
 5029        port_override=None,
 5030        secret_store_id=None,
 5031        tags=None,
 5032        tls_required=None,
 5033    ):
 5034        self.bind_interface = bind_interface if bind_interface is not None else ''
 5035        '''
 5036         Bind interface
 5037        '''
 5038        self.egress_filter = egress_filter if egress_filter is not None else ''
 5039        '''
 5040         A filter applied to the routing logic to pin datasource to nodes.
 5041        '''
 5042        self.healthy = healthy if healthy is not None else False
 5043        '''
 5044         True if the datasource is reachable and the credentials are valid.
 5045        '''
 5046        self.hostname = hostname if hostname is not None else ''
 5047        '''
 5048
 5049        '''
 5050        self.id = id if id is not None else ''
 5051        '''
 5052         Unique identifier of the Resource.
 5053        '''
 5054        self.name = name if name is not None else ''
 5055        '''
 5056         Unique human-readable name of the Resource.
 5057        '''
 5058        self.password = password if password is not None else ''
 5059        '''
 5060
 5061        '''
 5062        self.port = port if port is not None else 0
 5063        '''
 5064
 5065        '''
 5066        self.port_override = port_override if port_override is not None else 0
 5067        '''
 5068
 5069        '''
 5070        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5071        '''
 5072         ID of the secret store containing credentials for this resource, if any.
 5073        '''
 5074        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5075        '''
 5076         Tags is a map of key, value pairs.
 5077        '''
 5078        self.tls_required = tls_required if tls_required is not None else False
 5079        '''
 5080
 5081        '''
 5082
 5083    def __repr__(self):
 5084        return '<sdm.ElasticacheRedis ' + \
 5085            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5086            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5087            'healthy: ' + repr(self.healthy) + ' ' +\
 5088            'hostname: ' + repr(self.hostname) + ' ' +\
 5089            'id: ' + repr(self.id) + ' ' +\
 5090            'name: ' + repr(self.name) + ' ' +\
 5091            'password: ' + repr(self.password) + ' ' +\
 5092            'port: ' + repr(self.port) + ' ' +\
 5093            'port_override: ' + repr(self.port_override) + ' ' +\
 5094            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5095            'tags: ' + repr(self.tags) + ' ' +\
 5096            'tls_required: ' + repr(self.tls_required) + ' ' +\
 5097            '>'
 5098
 5099    def to_dict(self):
 5100        return {
 5101            'bind_interface': self.bind_interface,
 5102            'egress_filter': self.egress_filter,
 5103            'healthy': self.healthy,
 5104            'hostname': self.hostname,
 5105            'id': self.id,
 5106            'name': self.name,
 5107            'password': self.password,
 5108            'port': self.port,
 5109            'port_override': self.port_override,
 5110            'secret_store_id': self.secret_store_id,
 5111            'tags': self.tags,
 5112            'tls_required': self.tls_required,
 5113        }
 5114
 5115    @classmethod
 5116    def from_dict(cls, d):
 5117        return cls(
 5118            bind_interface=d.get('bind_interface'),
 5119            egress_filter=d.get('egress_filter'),
 5120            healthy=d.get('healthy'),
 5121            hostname=d.get('hostname'),
 5122            id=d.get('id'),
 5123            name=d.get('name'),
 5124            password=d.get('password'),
 5125            port=d.get('port'),
 5126            port_override=d.get('port_override'),
 5127            secret_store_id=d.get('secret_store_id'),
 5128            tags=d.get('tags'),
 5129            tls_required=d.get('tls_required'),
 5130        )
 5131
 5132
 5133class GCP:
 5134    '''
 5135
 5136    '''
 5137    __slots__ = [
 5138        'bind_interface',
 5139        'egress_filter',
 5140        'healthy',
 5141        'id',
 5142        'keyfile',
 5143        'name',
 5144        'scopes',
 5145        'secret_store_id',
 5146        'tags',
 5147    ]
 5148
 5149    def __init__(
 5150        self,
 5151        bind_interface=None,
 5152        egress_filter=None,
 5153        healthy=None,
 5154        id=None,
 5155        keyfile=None,
 5156        name=None,
 5157        scopes=None,
 5158        secret_store_id=None,
 5159        tags=None,
 5160    ):
 5161        self.bind_interface = bind_interface if bind_interface is not None else ''
 5162        '''
 5163         Bind interface
 5164        '''
 5165        self.egress_filter = egress_filter if egress_filter is not None else ''
 5166        '''
 5167         A filter applied to the routing logic to pin datasource to nodes.
 5168        '''
 5169        self.healthy = healthy if healthy is not None else False
 5170        '''
 5171         True if the datasource is reachable and the credentials are valid.
 5172        '''
 5173        self.id = id if id is not None else ''
 5174        '''
 5175         Unique identifier of the Resource.
 5176        '''
 5177        self.keyfile = keyfile if keyfile is not None else ''
 5178        '''
 5179
 5180        '''
 5181        self.name = name if name is not None else ''
 5182        '''
 5183         Unique human-readable name of the Resource.
 5184        '''
 5185        self.scopes = scopes if scopes is not None else ''
 5186        '''
 5187
 5188        '''
 5189        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5190        '''
 5191         ID of the secret store containing credentials for this resource, if any.
 5192        '''
 5193        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5194        '''
 5195         Tags is a map of key, value pairs.
 5196        '''
 5197
 5198    def __repr__(self):
 5199        return '<sdm.GCP ' + \
 5200            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5201            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5202            'healthy: ' + repr(self.healthy) + ' ' +\
 5203            'id: ' + repr(self.id) + ' ' +\
 5204            'keyfile: ' + repr(self.keyfile) + ' ' +\
 5205            'name: ' + repr(self.name) + ' ' +\
 5206            'scopes: ' + repr(self.scopes) + ' ' +\
 5207            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5208            'tags: ' + repr(self.tags) + ' ' +\
 5209            '>'
 5210
 5211    def to_dict(self):
 5212        return {
 5213            'bind_interface': self.bind_interface,
 5214            'egress_filter': self.egress_filter,
 5215            'healthy': self.healthy,
 5216            'id': self.id,
 5217            'keyfile': self.keyfile,
 5218            'name': self.name,
 5219            'scopes': self.scopes,
 5220            'secret_store_id': self.secret_store_id,
 5221            'tags': self.tags,
 5222        }
 5223
 5224    @classmethod
 5225    def from_dict(cls, d):
 5226        return cls(
 5227            bind_interface=d.get('bind_interface'),
 5228            egress_filter=d.get('egress_filter'),
 5229            healthy=d.get('healthy'),
 5230            id=d.get('id'),
 5231            keyfile=d.get('keyfile'),
 5232            name=d.get('name'),
 5233            scopes=d.get('scopes'),
 5234            secret_store_id=d.get('secret_store_id'),
 5235            tags=d.get('tags'),
 5236        )
 5237
 5238
 5239class GCPStore:
 5240    '''
 5241
 5242    '''
 5243    __slots__ = [
 5244        'id',
 5245        'name',
 5246        'projectid',
 5247        'tags',
 5248    ]
 5249
 5250    def __init__(
 5251        self,
 5252        id=None,
 5253        name=None,
 5254        projectid=None,
 5255        tags=None,
 5256    ):
 5257        self.id = id if id is not None else ''
 5258        '''
 5259         Unique identifier of the SecretStore.
 5260        '''
 5261        self.name = name if name is not None else ''
 5262        '''
 5263         Unique human-readable name of the SecretStore.
 5264        '''
 5265        self.projectid = projectid if projectid is not None else ''
 5266        '''
 5267
 5268        '''
 5269        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5270        '''
 5271         Tags is a map of key, value pairs.
 5272        '''
 5273
 5274    def __repr__(self):
 5275        return '<sdm.GCPStore ' + \
 5276            'id: ' + repr(self.id) + ' ' +\
 5277            'name: ' + repr(self.name) + ' ' +\
 5278            'projectid: ' + repr(self.projectid) + ' ' +\
 5279            'tags: ' + repr(self.tags) + ' ' +\
 5280            '>'
 5281
 5282    def to_dict(self):
 5283        return {
 5284            'id': self.id,
 5285            'name': self.name,
 5286            'projectid': self.projectid,
 5287            'tags': self.tags,
 5288        }
 5289
 5290    @classmethod
 5291    def from_dict(cls, d):
 5292        return cls(
 5293            id=d.get('id'),
 5294            name=d.get('name'),
 5295            projectid=d.get('projectid'),
 5296            tags=d.get('tags'),
 5297        )
 5298
 5299
 5300class Gateway:
 5301    '''
 5302     Gateway represents a StrongDM CLI installation running in gateway mode.
 5303    '''
 5304    __slots__ = [
 5305        'bind_address',
 5306        'gateway_filter',
 5307        'id',
 5308        'listen_address',
 5309        'name',
 5310        'state',
 5311        'tags',
 5312    ]
 5313
 5314    def __init__(
 5315        self,
 5316        bind_address=None,
 5317        gateway_filter=None,
 5318        id=None,
 5319        listen_address=None,
 5320        name=None,
 5321        state=None,
 5322        tags=None,
 5323    ):
 5324        self.bind_address = bind_address if bind_address is not None else ''
 5325        '''
 5326         The hostname/port tuple which the gateway daemon will bind to.
 5327         If not provided on create, set to "0.0.0.0:listen_address_port".
 5328        '''
 5329        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
 5330        '''
 5331         GatewayFilter can be used to restrict the peering between relays and
 5332         gateways.
 5333        '''
 5334        self.id = id if id is not None else ''
 5335        '''
 5336         Unique identifier of the Gateway.
 5337        '''
 5338        self.listen_address = listen_address if listen_address is not None else ''
 5339        '''
 5340         The public hostname/port tuple at which the gateway will be accessible to clients.
 5341        '''
 5342        self.name = name if name is not None else ''
 5343        '''
 5344         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
 5345        '''
 5346        self.state = state if state is not None else ''
 5347        '''
 5348         The current state of the gateway. One of: "new", "verifying_restart",
 5349         "restarting", "started", "stopped", "dead", "unknown"
 5350        '''
 5351        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5352        '''
 5353         Tags is a map of key, value pairs.
 5354        '''
 5355
 5356    def __repr__(self):
 5357        return '<sdm.Gateway ' + \
 5358            'bind_address: ' + repr(self.bind_address) + ' ' +\
 5359            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
 5360            'id: ' + repr(self.id) + ' ' +\
 5361            'listen_address: ' + repr(self.listen_address) + ' ' +\
 5362            'name: ' + repr(self.name) + ' ' +\
 5363            'state: ' + repr(self.state) + ' ' +\
 5364            'tags: ' + repr(self.tags) + ' ' +\
 5365            '>'
 5366
 5367    def to_dict(self):
 5368        return {
 5369            'bind_address': self.bind_address,
 5370            'gateway_filter': self.gateway_filter,
 5371            'id': self.id,
 5372            'listen_address': self.listen_address,
 5373            'name': self.name,
 5374            'state': self.state,
 5375            'tags': self.tags,
 5376        }
 5377
 5378    @classmethod
 5379    def from_dict(cls, d):
 5380        return cls(
 5381            bind_address=d.get('bind_address'),
 5382            gateway_filter=d.get('gateway_filter'),
 5383            id=d.get('id'),
 5384            listen_address=d.get('listen_address'),
 5385            name=d.get('name'),
 5386            state=d.get('state'),
 5387            tags=d.get('tags'),
 5388        )
 5389
 5390
 5391class GetResponseMetadata:
 5392    '''
 5393     GetResponseMetadata is reserved for future use.
 5394    '''
 5395    __slots__ = []
 5396
 5397    def __init__(self, ):
 5398        pass
 5399
 5400    def __repr__(self):
 5401        return '<sdm.GetResponseMetadata ' + \
 5402            '>'
 5403
 5404    def to_dict(self):
 5405        return {}
 5406
 5407    @classmethod
 5408    def from_dict(cls, d):
 5409        return cls()
 5410
 5411
 5412class GoogleGKE:
 5413    '''
 5414
 5415    '''
 5416    __slots__ = [
 5417        'bind_interface',
 5418        'certificate_authority',
 5419        'egress_filter',
 5420        'endpoint',
 5421        'healthcheck_namespace',
 5422        'healthy',
 5423        'id',
 5424        'name',
 5425        'remote_identity_group_id',
 5426        'remote_identity_healthcheck_username',
 5427        'secret_store_id',
 5428        'service_account_key',
 5429        'tags',
 5430    ]
 5431
 5432    def __init__(
 5433        self,
 5434        bind_interface=None,
 5435        certificate_authority=None,
 5436        egress_filter=None,
 5437        endpoint=None,
 5438        healthcheck_namespace=None,
 5439        healthy=None,
 5440        id=None,
 5441        name=None,
 5442        remote_identity_group_id=None,
 5443        remote_identity_healthcheck_username=None,
 5444        secret_store_id=None,
 5445        service_account_key=None,
 5446        tags=None,
 5447    ):
 5448        self.bind_interface = bind_interface if bind_interface is not None else ''
 5449        '''
 5450         Bind interface
 5451        '''
 5452        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 5453        '''
 5454
 5455        '''
 5456        self.egress_filter = egress_filter if egress_filter is not None else ''
 5457        '''
 5458         A filter applied to the routing logic to pin datasource to nodes.
 5459        '''
 5460        self.endpoint = endpoint if endpoint is not None else ''
 5461        '''
 5462
 5463        '''
 5464        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 5465        '''
 5466         The path used to check the health of your connection.  Defaults to `default`.
 5467        '''
 5468        self.healthy = healthy if healthy is not None else False
 5469        '''
 5470         True if the datasource is reachable and the credentials are valid.
 5471        '''
 5472        self.id = id if id is not None else ''
 5473        '''
 5474         Unique identifier of the Resource.
 5475        '''
 5476        self.name = name if name is not None else ''
 5477        '''
 5478         Unique human-readable name of the Resource.
 5479        '''
 5480        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 5481        '''
 5482
 5483        '''
 5484        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 5485        '''
 5486
 5487        '''
 5488        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5489        '''
 5490         ID of the secret store containing credentials for this resource, if any.
 5491        '''
 5492        self.service_account_key = service_account_key if service_account_key is not None else ''
 5493        '''
 5494
 5495        '''
 5496        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5497        '''
 5498         Tags is a map of key, value pairs.
 5499        '''
 5500
 5501    def __repr__(self):
 5502        return '<sdm.GoogleGKE ' + \
 5503            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5504            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 5505            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5506            'endpoint: ' + repr(self.endpoint) + ' ' +\
 5507            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 5508            'healthy: ' + repr(self.healthy) + ' ' +\
 5509            'id: ' + repr(self.id) + ' ' +\
 5510            'name: ' + repr(self.name) + ' ' +\
 5511            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 5512            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 5513            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5514            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
 5515            'tags: ' + repr(self.tags) + ' ' +\
 5516            '>'
 5517
 5518    def to_dict(self):
 5519        return {
 5520            'bind_interface': self.bind_interface,
 5521            'certificate_authority': self.certificate_authority,
 5522            'egress_filter': self.egress_filter,
 5523            'endpoint': self.endpoint,
 5524            'healthcheck_namespace': self.healthcheck_namespace,
 5525            'healthy': self.healthy,
 5526            'id': self.id,
 5527            'name': self.name,
 5528            'remote_identity_group_id': self.remote_identity_group_id,
 5529            'remote_identity_healthcheck_username':
 5530            self.remote_identity_healthcheck_username,
 5531            'secret_store_id': self.secret_store_id,
 5532            'service_account_key': self.service_account_key,
 5533            'tags': self.tags,
 5534        }
 5535
 5536    @classmethod
 5537    def from_dict(cls, d):
 5538        return cls(
 5539            bind_interface=d.get('bind_interface'),
 5540            certificate_authority=d.get('certificate_authority'),
 5541            egress_filter=d.get('egress_filter'),
 5542            endpoint=d.get('endpoint'),
 5543            healthcheck_namespace=d.get('healthcheck_namespace'),
 5544            healthy=d.get('healthy'),
 5545            id=d.get('id'),
 5546            name=d.get('name'),
 5547            remote_identity_group_id=d.get('remote_identity_group_id'),
 5548            remote_identity_healthcheck_username=d.get(
 5549                'remote_identity_healthcheck_username'),
 5550            secret_store_id=d.get('secret_store_id'),
 5551            service_account_key=d.get('service_account_key'),
 5552            tags=d.get('tags'),
 5553        )
 5554
 5555
 5556class GoogleGKEUserImpersonation:
 5557    '''
 5558
 5559    '''
 5560    __slots__ = [
 5561        'bind_interface',
 5562        'certificate_authority',
 5563        'egress_filter',
 5564        'endpoint',
 5565        'healthcheck_namespace',
 5566        'healthy',
 5567        'id',
 5568        'name',
 5569        'secret_store_id',
 5570        'service_account_key',
 5571        'tags',
 5572    ]
 5573
 5574    def __init__(
 5575        self,
 5576        bind_interface=None,
 5577        certificate_authority=None,
 5578        egress_filter=None,
 5579        endpoint=None,
 5580        healthcheck_namespace=None,
 5581        healthy=None,
 5582        id=None,
 5583        name=None,
 5584        secret_store_id=None,
 5585        service_account_key=None,
 5586        tags=None,
 5587    ):
 5588        self.bind_interface = bind_interface if bind_interface is not None else ''
 5589        '''
 5590         Bind interface
 5591        '''
 5592        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 5593        '''
 5594
 5595        '''
 5596        self.egress_filter = egress_filter if egress_filter is not None else ''
 5597        '''
 5598         A filter applied to the routing logic to pin datasource to nodes.
 5599        '''
 5600        self.endpoint = endpoint if endpoint is not None else ''
 5601        '''
 5602
 5603        '''
 5604        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 5605        '''
 5606         The path used to check the health of your connection.  Defaults to `default`.
 5607        '''
 5608        self.healthy = healthy if healthy is not None else False
 5609        '''
 5610         True if the datasource is reachable and the credentials are valid.
 5611        '''
 5612        self.id = id if id is not None else ''
 5613        '''
 5614         Unique identifier of the Resource.
 5615        '''
 5616        self.name = name if name is not None else ''
 5617        '''
 5618         Unique human-readable name of the Resource.
 5619        '''
 5620        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5621        '''
 5622         ID of the secret store containing credentials for this resource, if any.
 5623        '''
 5624        self.service_account_key = service_account_key if service_account_key is not None else ''
 5625        '''
 5626
 5627        '''
 5628        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5629        '''
 5630         Tags is a map of key, value pairs.
 5631        '''
 5632
 5633    def __repr__(self):
 5634        return '<sdm.GoogleGKEUserImpersonation ' + \
 5635            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5636            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 5637            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5638            'endpoint: ' + repr(self.endpoint) + ' ' +\
 5639            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 5640            'healthy: ' + repr(self.healthy) + ' ' +\
 5641            'id: ' + repr(self.id) + ' ' +\
 5642            'name: ' + repr(self.name) + ' ' +\
 5643            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5644            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
 5645            'tags: ' + repr(self.tags) + ' ' +\
 5646            '>'
 5647
 5648    def to_dict(self):
 5649        return {
 5650            'bind_interface': self.bind_interface,
 5651            'certificate_authority': self.certificate_authority,
 5652            'egress_filter': self.egress_filter,
 5653            'endpoint': self.endpoint,
 5654            'healthcheck_namespace': self.healthcheck_namespace,
 5655            'healthy': self.healthy,
 5656            'id': self.id,
 5657            'name': self.name,
 5658            'secret_store_id': self.secret_store_id,
 5659            'service_account_key': self.service_account_key,
 5660            'tags': self.tags,
 5661        }
 5662
 5663    @classmethod
 5664    def from_dict(cls, d):
 5665        return cls(
 5666            bind_interface=d.get('bind_interface'),
 5667            certificate_authority=d.get('certificate_authority'),
 5668            egress_filter=d.get('egress_filter'),
 5669            endpoint=d.get('endpoint'),
 5670            healthcheck_namespace=d.get('healthcheck_namespace'),
 5671            healthy=d.get('healthy'),
 5672            id=d.get('id'),
 5673            name=d.get('name'),
 5674            secret_store_id=d.get('secret_store_id'),
 5675            service_account_key=d.get('service_account_key'),
 5676            tags=d.get('tags'),
 5677        )
 5678
 5679
 5680class Greenplum:
 5681    '''
 5682
 5683    '''
 5684    __slots__ = [
 5685        'bind_interface',
 5686        'database',
 5687        'egress_filter',
 5688        'healthy',
 5689        'hostname',
 5690        'id',
 5691        'name',
 5692        'override_database',
 5693        'password',
 5694        'port',
 5695        'port_override',
 5696        'secret_store_id',
 5697        'tags',
 5698        'username',
 5699    ]
 5700
 5701    def __init__(
 5702        self,
 5703        bind_interface=None,
 5704        database=None,
 5705        egress_filter=None,
 5706        healthy=None,
 5707        hostname=None,
 5708        id=None,
 5709        name=None,
 5710        override_database=None,
 5711        password=None,
 5712        port=None,
 5713        port_override=None,
 5714        secret_store_id=None,
 5715        tags=None,
 5716        username=None,
 5717    ):
 5718        self.bind_interface = bind_interface if bind_interface is not None else ''
 5719        '''
 5720         Bind interface
 5721        '''
 5722        self.database = database if database is not None else ''
 5723        '''
 5724
 5725        '''
 5726        self.egress_filter = egress_filter if egress_filter is not None else ''
 5727        '''
 5728         A filter applied to the routing logic to pin datasource to nodes.
 5729        '''
 5730        self.healthy = healthy if healthy is not None else False
 5731        '''
 5732         True if the datasource is reachable and the credentials are valid.
 5733        '''
 5734        self.hostname = hostname if hostname is not None else ''
 5735        '''
 5736
 5737        '''
 5738        self.id = id if id is not None else ''
 5739        '''
 5740         Unique identifier of the Resource.
 5741        '''
 5742        self.name = name if name is not None else ''
 5743        '''
 5744         Unique human-readable name of the Resource.
 5745        '''
 5746        self.override_database = override_database if override_database is not None else False
 5747        '''
 5748
 5749        '''
 5750        self.password = password if password is not None else ''
 5751        '''
 5752
 5753        '''
 5754        self.port = port if port is not None else 0
 5755        '''
 5756
 5757        '''
 5758        self.port_override = port_override if port_override is not None else 0
 5759        '''
 5760
 5761        '''
 5762        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5763        '''
 5764         ID of the secret store containing credentials for this resource, if any.
 5765        '''
 5766        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5767        '''
 5768         Tags is a map of key, value pairs.
 5769        '''
 5770        self.username = username if username is not None else ''
 5771        '''
 5772
 5773        '''
 5774
 5775    def __repr__(self):
 5776        return '<sdm.Greenplum ' + \
 5777            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5778            'database: ' + repr(self.database) + ' ' +\
 5779            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5780            'healthy: ' + repr(self.healthy) + ' ' +\
 5781            'hostname: ' + repr(self.hostname) + ' ' +\
 5782            'id: ' + repr(self.id) + ' ' +\
 5783            'name: ' + repr(self.name) + ' ' +\
 5784            'override_database: ' + repr(self.override_database) + ' ' +\
 5785            'password: ' + repr(self.password) + ' ' +\
 5786            'port: ' + repr(self.port) + ' ' +\
 5787            'port_override: ' + repr(self.port_override) + ' ' +\
 5788            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5789            'tags: ' + repr(self.tags) + ' ' +\
 5790            'username: ' + repr(self.username) + ' ' +\
 5791            '>'
 5792
 5793    def to_dict(self):
 5794        return {
 5795            'bind_interface': self.bind_interface,
 5796            'database': self.database,
 5797            'egress_filter': self.egress_filter,
 5798            'healthy': self.healthy,
 5799            'hostname': self.hostname,
 5800            'id': self.id,
 5801            'name': self.name,
 5802            'override_database': self.override_database,
 5803            'password': self.password,
 5804            'port': self.port,
 5805            'port_override': self.port_override,
 5806            'secret_store_id': self.secret_store_id,
 5807            'tags': self.tags,
 5808            'username': self.username,
 5809        }
 5810
 5811    @classmethod
 5812    def from_dict(cls, d):
 5813        return cls(
 5814            bind_interface=d.get('bind_interface'),
 5815            database=d.get('database'),
 5816            egress_filter=d.get('egress_filter'),
 5817            healthy=d.get('healthy'),
 5818            hostname=d.get('hostname'),
 5819            id=d.get('id'),
 5820            name=d.get('name'),
 5821            override_database=d.get('override_database'),
 5822            password=d.get('password'),
 5823            port=d.get('port'),
 5824            port_override=d.get('port_override'),
 5825            secret_store_id=d.get('secret_store_id'),
 5826            tags=d.get('tags'),
 5827            username=d.get('username'),
 5828        )
 5829
 5830
 5831class HTTPAuth:
 5832    '''
 5833
 5834    '''
 5835    __slots__ = [
 5836        'auth_header',
 5837        'bind_interface',
 5838        'default_path',
 5839        'egress_filter',
 5840        'headers_blacklist',
 5841        'healthcheck_path',
 5842        'healthy',
 5843        'id',
 5844        'name',
 5845        'secret_store_id',
 5846        'subdomain',
 5847        'tags',
 5848        'url',
 5849    ]
 5850
 5851    def __init__(
 5852        self,
 5853        auth_header=None,
 5854        bind_interface=None,
 5855        default_path=None,
 5856        egress_filter=None,
 5857        headers_blacklist=None,
 5858        healthcheck_path=None,
 5859        healthy=None,
 5860        id=None,
 5861        name=None,
 5862        secret_store_id=None,
 5863        subdomain=None,
 5864        tags=None,
 5865        url=None,
 5866    ):
 5867        self.auth_header = auth_header if auth_header is not None else ''
 5868        '''
 5869
 5870        '''
 5871        self.bind_interface = bind_interface if bind_interface is not None else ''
 5872        '''
 5873         Bind interface
 5874        '''
 5875        self.default_path = default_path if default_path is not None else ''
 5876        '''
 5877
 5878        '''
 5879        self.egress_filter = egress_filter if egress_filter is not None else ''
 5880        '''
 5881         A filter applied to the routing logic to pin datasource to nodes.
 5882        '''
 5883        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 5884        '''
 5885
 5886        '''
 5887        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 5888        '''
 5889
 5890        '''
 5891        self.healthy = healthy if healthy is not None else False
 5892        '''
 5893         True if the datasource is reachable and the credentials are valid.
 5894        '''
 5895        self.id = id if id is not None else ''
 5896        '''
 5897         Unique identifier of the Resource.
 5898        '''
 5899        self.name = name if name is not None else ''
 5900        '''
 5901         Unique human-readable name of the Resource.
 5902        '''
 5903        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5904        '''
 5905         ID of the secret store containing credentials for this resource, if any.
 5906        '''
 5907        self.subdomain = subdomain if subdomain is not None else ''
 5908        '''
 5909
 5910        '''
 5911        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5912        '''
 5913         Tags is a map of key, value pairs.
 5914        '''
 5915        self.url = url if url is not None else ''
 5916        '''
 5917
 5918        '''
 5919
 5920    def __repr__(self):
 5921        return '<sdm.HTTPAuth ' + \
 5922            'auth_header: ' + repr(self.auth_header) + ' ' +\
 5923            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5924            'default_path: ' + repr(self.default_path) + ' ' +\
 5925            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5926            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 5927            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 5928            'healthy: ' + repr(self.healthy) + ' ' +\
 5929            'id: ' + repr(self.id) + ' ' +\
 5930            'name: ' + repr(self.name) + ' ' +\
 5931            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5932            'subdomain: ' + repr(self.subdomain) + ' ' +\
 5933            'tags: ' + repr(self.tags) + ' ' +\
 5934            'url: ' + repr(self.url) + ' ' +\
 5935            '>'
 5936
 5937    def to_dict(self):
 5938        return {
 5939            'auth_header': self.auth_header,
 5940            'bind_interface': self.bind_interface,
 5941            'default_path': self.default_path,
 5942            'egress_filter': self.egress_filter,
 5943            'headers_blacklist': self.headers_blacklist,
 5944            'healthcheck_path': self.healthcheck_path,
 5945            'healthy': self.healthy,
 5946            'id': self.id,
 5947            'name': self.name,
 5948            'secret_store_id': self.secret_store_id,
 5949            'subdomain': self.subdomain,
 5950            'tags': self.tags,
 5951            'url': self.url,
 5952        }
 5953
 5954    @classmethod
 5955    def from_dict(cls, d):
 5956        return cls(
 5957            auth_header=d.get('auth_header'),
 5958            bind_interface=d.get('bind_interface'),
 5959            default_path=d.get('default_path'),
 5960            egress_filter=d.get('egress_filter'),
 5961            headers_blacklist=d.get('headers_blacklist'),
 5962            healthcheck_path=d.get('healthcheck_path'),
 5963            healthy=d.get('healthy'),
 5964            id=d.get('id'),
 5965            name=d.get('name'),
 5966            secret_store_id=d.get('secret_store_id'),
 5967            subdomain=d.get('subdomain'),
 5968            tags=d.get('tags'),
 5969            url=d.get('url'),
 5970        )
 5971
 5972
 5973class HTTPBasicAuth:
 5974    '''
 5975
 5976    '''
 5977    __slots__ = [
 5978        'bind_interface',
 5979        'default_path',
 5980        'egress_filter',
 5981        'headers_blacklist',
 5982        'healthcheck_path',
 5983        'healthy',
 5984        'id',
 5985        'name',
 5986        'password',
 5987        'secret_store_id',
 5988        'subdomain',
 5989        'tags',
 5990        'url',
 5991        'username',
 5992    ]
 5993
 5994    def __init__(
 5995        self,
 5996        bind_interface=None,
 5997        default_path=None,
 5998        egress_filter=None,
 5999        headers_blacklist=None,
 6000        healthcheck_path=None,
 6001        healthy=None,
 6002        id=None,
 6003        name=None,
 6004        password=None,
 6005        secret_store_id=None,
 6006        subdomain=None,
 6007        tags=None,
 6008        url=None,
 6009        username=None,
 6010    ):
 6011        self.bind_interface = bind_interface if bind_interface is not None else ''
 6012        '''
 6013         Bind interface
 6014        '''
 6015        self.default_path = default_path if default_path is not None else ''
 6016        '''
 6017
 6018        '''
 6019        self.egress_filter = egress_filter if egress_filter is not None else ''
 6020        '''
 6021         A filter applied to the routing logic to pin datasource to nodes.
 6022        '''
 6023        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 6024        '''
 6025
 6026        '''
 6027        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 6028        '''
 6029
 6030        '''
 6031        self.healthy = healthy if healthy is not None else False
 6032        '''
 6033         True if the datasource is reachable and the credentials are valid.
 6034        '''
 6035        self.id = id if id is not None else ''
 6036        '''
 6037         Unique identifier of the Resource.
 6038        '''
 6039        self.name = name if name is not None else ''
 6040        '''
 6041         Unique human-readable name of the Resource.
 6042        '''
 6043        self.password = password if password is not None else ''
 6044        '''
 6045
 6046        '''
 6047        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6048        '''
 6049         ID of the secret store containing credentials for this resource, if any.
 6050        '''
 6051        self.subdomain = subdomain if subdomain is not None else ''
 6052        '''
 6053
 6054        '''
 6055        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6056        '''
 6057         Tags is a map of key, value pairs.
 6058        '''
 6059        self.url = url if url is not None else ''
 6060        '''
 6061
 6062        '''
 6063        self.username = username if username is not None else ''
 6064        '''
 6065
 6066        '''
 6067
 6068    def __repr__(self):
 6069        return '<sdm.HTTPBasicAuth ' + \
 6070            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6071            'default_path: ' + repr(self.default_path) + ' ' +\
 6072            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6073            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 6074            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 6075            'healthy: ' + repr(self.healthy) + ' ' +\
 6076            'id: ' + repr(self.id) + ' ' +\
 6077            'name: ' + repr(self.name) + ' ' +\
 6078            'password: ' + repr(self.password) + ' ' +\
 6079            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6080            'subdomain: ' + repr(self.subdomain) + ' ' +\
 6081            'tags: ' + repr(self.tags) + ' ' +\
 6082            'url: ' + repr(self.url) + ' ' +\
 6083            'username: ' + repr(self.username) + ' ' +\
 6084            '>'
 6085
 6086    def to_dict(self):
 6087        return {
 6088            'bind_interface': self.bind_interface,
 6089            'default_path': self.default_path,
 6090            'egress_filter': self.egress_filter,
 6091            'headers_blacklist': self.headers_blacklist,
 6092            'healthcheck_path': self.healthcheck_path,
 6093            'healthy': self.healthy,
 6094            'id': self.id,
 6095            'name': self.name,
 6096            'password': self.password,
 6097            'secret_store_id': self.secret_store_id,
 6098            'subdomain': self.subdomain,
 6099            'tags': self.tags,
 6100            'url': self.url,
 6101            'username': self.username,
 6102        }
 6103
 6104    @classmethod
 6105    def from_dict(cls, d):
 6106        return cls(
 6107            bind_interface=d.get('bind_interface'),
 6108            default_path=d.get('default_path'),
 6109            egress_filter=d.get('egress_filter'),
 6110            headers_blacklist=d.get('headers_blacklist'),
 6111            healthcheck_path=d.get('healthcheck_path'),
 6112            healthy=d.get('healthy'),
 6113            id=d.get('id'),
 6114            name=d.get('name'),
 6115            password=d.get('password'),
 6116            secret_store_id=d.get('secret_store_id'),
 6117            subdomain=d.get('subdomain'),
 6118            tags=d.get('tags'),
 6119            url=d.get('url'),
 6120            username=d.get('username'),
 6121        )
 6122
 6123
 6124class HTTPNoAuth:
 6125    '''
 6126
 6127    '''
 6128    __slots__ = [
 6129        'bind_interface',
 6130        'default_path',
 6131        'egress_filter',
 6132        'headers_blacklist',
 6133        'healthcheck_path',
 6134        'healthy',
 6135        'id',
 6136        'name',
 6137        'secret_store_id',
 6138        'subdomain',
 6139        'tags',
 6140        'url',
 6141    ]
 6142
 6143    def __init__(
 6144        self,
 6145        bind_interface=None,
 6146        default_path=None,
 6147        egress_filter=None,
 6148        headers_blacklist=None,
 6149        healthcheck_path=None,
 6150        healthy=None,
 6151        id=None,
 6152        name=None,
 6153        secret_store_id=None,
 6154        subdomain=None,
 6155        tags=None,
 6156        url=None,
 6157    ):
 6158        self.bind_interface = bind_interface if bind_interface is not None else ''
 6159        '''
 6160         Bind interface
 6161        '''
 6162        self.default_path = default_path if default_path is not None else ''
 6163        '''
 6164
 6165        '''
 6166        self.egress_filter = egress_filter if egress_filter is not None else ''
 6167        '''
 6168         A filter applied to the routing logic to pin datasource to nodes.
 6169        '''
 6170        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 6171        '''
 6172
 6173        '''
 6174        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 6175        '''
 6176
 6177        '''
 6178        self.healthy = healthy if healthy is not None else False
 6179        '''
 6180         True if the datasource is reachable and the credentials are valid.
 6181        '''
 6182        self.id = id if id is not None else ''
 6183        '''
 6184         Unique identifier of the Resource.
 6185        '''
 6186        self.name = name if name is not None else ''
 6187        '''
 6188         Unique human-readable name of the Resource.
 6189        '''
 6190        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6191        '''
 6192         ID of the secret store containing credentials for this resource, if any.
 6193        '''
 6194        self.subdomain = subdomain if subdomain is not None else ''
 6195        '''
 6196
 6197        '''
 6198        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6199        '''
 6200         Tags is a map of key, value pairs.
 6201        '''
 6202        self.url = url if url is not None else ''
 6203        '''
 6204
 6205        '''
 6206
 6207    def __repr__(self):
 6208        return '<sdm.HTTPNoAuth ' + \
 6209            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6210            'default_path: ' + repr(self.default_path) + ' ' +\
 6211            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6212            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 6213            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 6214            'healthy: ' + repr(self.healthy) + ' ' +\
 6215            'id: ' + repr(self.id) + ' ' +\
 6216            'name: ' + repr(self.name) + ' ' +\
 6217            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6218            'subdomain: ' + repr(self.subdomain) + ' ' +\
 6219            'tags: ' + repr(self.tags) + ' ' +\
 6220            'url: ' + repr(self.url) + ' ' +\
 6221            '>'
 6222
 6223    def to_dict(self):
 6224        return {
 6225            'bind_interface': self.bind_interface,
 6226            'default_path': self.default_path,
 6227            'egress_filter': self.egress_filter,
 6228            'headers_blacklist': self.headers_blacklist,
 6229            'healthcheck_path': self.healthcheck_path,
 6230            'healthy': self.healthy,
 6231            'id': self.id,
 6232            'name': self.name,
 6233            'secret_store_id': self.secret_store_id,
 6234            'subdomain': self.subdomain,
 6235            'tags': self.tags,
 6236            'url': self.url,
 6237        }
 6238
 6239    @classmethod
 6240    def from_dict(cls, d):
 6241        return cls(
 6242            bind_interface=d.get('bind_interface'),
 6243            default_path=d.get('default_path'),
 6244            egress_filter=d.get('egress_filter'),
 6245            headers_blacklist=d.get('headers_blacklist'),
 6246            healthcheck_path=d.get('healthcheck_path'),
 6247            healthy=d.get('healthy'),
 6248            id=d.get('id'),
 6249            name=d.get('name'),
 6250            secret_store_id=d.get('secret_store_id'),
 6251            subdomain=d.get('subdomain'),
 6252            tags=d.get('tags'),
 6253            url=d.get('url'),
 6254        )
 6255
 6256
 6257class Kubernetes:
 6258    '''
 6259
 6260    '''
 6261    __slots__ = [
 6262        'bind_interface',
 6263        'certificate_authority',
 6264        'client_certificate',
 6265        'client_key',
 6266        'egress_filter',
 6267        'healthcheck_namespace',
 6268        'healthy',
 6269        'hostname',
 6270        'id',
 6271        'name',
 6272        'port',
 6273        'port_override',
 6274        'remote_identity_group_id',
 6275        'remote_identity_healthcheck_username',
 6276        'secret_store_id',
 6277        'tags',
 6278    ]
 6279
 6280    def __init__(
 6281        self,
 6282        bind_interface=None,
 6283        certificate_authority=None,
 6284        client_certificate=None,
 6285        client_key=None,
 6286        egress_filter=None,
 6287        healthcheck_namespace=None,
 6288        healthy=None,
 6289        hostname=None,
 6290        id=None,
 6291        name=None,
 6292        port=None,
 6293        port_override=None,
 6294        remote_identity_group_id=None,
 6295        remote_identity_healthcheck_username=None,
 6296        secret_store_id=None,
 6297        tags=None,
 6298    ):
 6299        self.bind_interface = bind_interface if bind_interface is not None else ''
 6300        '''
 6301         Bind interface
 6302        '''
 6303        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6304        '''
 6305
 6306        '''
 6307        self.client_certificate = client_certificate if client_certificate is not None else ''
 6308        '''
 6309
 6310        '''
 6311        self.client_key = client_key if client_key is not None else ''
 6312        '''
 6313
 6314        '''
 6315        self.egress_filter = egress_filter if egress_filter is not None else ''
 6316        '''
 6317         A filter applied to the routing logic to pin datasource to nodes.
 6318        '''
 6319        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6320        '''
 6321         The path used to check the health of your connection.  Defaults to `default`.
 6322        '''
 6323        self.healthy = healthy if healthy is not None else False
 6324        '''
 6325         True if the datasource is reachable and the credentials are valid.
 6326        '''
 6327        self.hostname = hostname if hostname is not None else ''
 6328        '''
 6329
 6330        '''
 6331        self.id = id if id is not None else ''
 6332        '''
 6333         Unique identifier of the Resource.
 6334        '''
 6335        self.name = name if name is not None else ''
 6336        '''
 6337         Unique human-readable name of the Resource.
 6338        '''
 6339        self.port = port if port is not None else 0
 6340        '''
 6341
 6342        '''
 6343        self.port_override = port_override if port_override is not None else 0
 6344        '''
 6345
 6346        '''
 6347        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 6348        '''
 6349
 6350        '''
 6351        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 6352        '''
 6353
 6354        '''
 6355        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6356        '''
 6357         ID of the secret store containing credentials for this resource, if any.
 6358        '''
 6359        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6360        '''
 6361         Tags is a map of key, value pairs.
 6362        '''
 6363
 6364    def __repr__(self):
 6365        return '<sdm.Kubernetes ' + \
 6366            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6367            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 6368            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 6369            'client_key: ' + repr(self.client_key) + ' ' +\
 6370            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6371            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6372            'healthy: ' + repr(self.healthy) + ' ' +\
 6373            'hostname: ' + repr(self.hostname) + ' ' +\
 6374            'id: ' + repr(self.id) + ' ' +\
 6375            'name: ' + repr(self.name) + ' ' +\
 6376            'port: ' + repr(self.port) + ' ' +\
 6377            'port_override: ' + repr(self.port_override) + ' ' +\
 6378            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 6379            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 6380            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6381            'tags: ' + repr(self.tags) + ' ' +\
 6382            '>'
 6383
 6384    def to_dict(self):
 6385        return {
 6386            'bind_interface': self.bind_interface,
 6387            'certificate_authority': self.certificate_authority,
 6388            'client_certificate': self.client_certificate,
 6389            'client_key': self.client_key,
 6390            'egress_filter': self.egress_filter,
 6391            'healthcheck_namespace': self.healthcheck_namespace,
 6392            'healthy': self.healthy,
 6393            'hostname': self.hostname,
 6394            'id': self.id,
 6395            'name': self.name,
 6396            'port': self.port,
 6397            'port_override': self.port_override,
 6398            'remote_identity_group_id': self.remote_identity_group_id,
 6399            'remote_identity_healthcheck_username':
 6400            self.remote_identity_healthcheck_username,
 6401            'secret_store_id': self.secret_store_id,
 6402            'tags': self.tags,
 6403        }
 6404
 6405    @classmethod
 6406    def from_dict(cls, d):
 6407        return cls(
 6408            bind_interface=d.get('bind_interface'),
 6409            certificate_authority=d.get('certificate_authority'),
 6410            client_certificate=d.get('client_certificate'),
 6411            client_key=d.get('client_key'),
 6412            egress_filter=d.get('egress_filter'),
 6413            healthcheck_namespace=d.get('healthcheck_namespace'),
 6414            healthy=d.get('healthy'),
 6415            hostname=d.get('hostname'),
 6416            id=d.get('id'),
 6417            name=d.get('name'),
 6418            port=d.get('port'),
 6419            port_override=d.get('port_override'),
 6420            remote_identity_group_id=d.get('remote_identity_group_id'),
 6421            remote_identity_healthcheck_username=d.get(
 6422                'remote_identity_healthcheck_username'),
 6423            secret_store_id=d.get('secret_store_id'),
 6424            tags=d.get('tags'),
 6425        )
 6426
 6427
 6428class KubernetesBasicAuth:
 6429    '''
 6430
 6431    '''
 6432    __slots__ = [
 6433        'bind_interface',
 6434        'egress_filter',
 6435        'healthcheck_namespace',
 6436        'healthy',
 6437        'hostname',
 6438        'id',
 6439        'name',
 6440        'password',
 6441        'port',
 6442        'port_override',
 6443        'secret_store_id',
 6444        'tags',
 6445        'username',
 6446    ]
 6447
 6448    def __init__(
 6449        self,
 6450        bind_interface=None,
 6451        egress_filter=None,
 6452        healthcheck_namespace=None,
 6453        healthy=None,
 6454        hostname=None,
 6455        id=None,
 6456        name=None,
 6457        password=None,
 6458        port=None,
 6459        port_override=None,
 6460        secret_store_id=None,
 6461        tags=None,
 6462        username=None,
 6463    ):
 6464        self.bind_interface = bind_interface if bind_interface is not None else ''
 6465        '''
 6466         Bind interface
 6467        '''
 6468        self.egress_filter = egress_filter if egress_filter is not None else ''
 6469        '''
 6470         A filter applied to the routing logic to pin datasource to nodes.
 6471        '''
 6472        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6473        '''
 6474         The path used to check the health of your connection.  Defaults to `default`.
 6475        '''
 6476        self.healthy = healthy if healthy is not None else False
 6477        '''
 6478         True if the datasource is reachable and the credentials are valid.
 6479        '''
 6480        self.hostname = hostname if hostname is not None else ''
 6481        '''
 6482
 6483        '''
 6484        self.id = id if id is not None else ''
 6485        '''
 6486         Unique identifier of the Resource.
 6487        '''
 6488        self.name = name if name is not None else ''
 6489        '''
 6490         Unique human-readable name of the Resource.
 6491        '''
 6492        self.password = password if password is not None else ''
 6493        '''
 6494
 6495        '''
 6496        self.port = port if port is not None else 0
 6497        '''
 6498
 6499        '''
 6500        self.port_override = port_override if port_override is not None else 0
 6501        '''
 6502
 6503        '''
 6504        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6505        '''
 6506         ID of the secret store containing credentials for this resource, if any.
 6507        '''
 6508        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6509        '''
 6510         Tags is a map of key, value pairs.
 6511        '''
 6512        self.username = username if username is not None else ''
 6513        '''
 6514
 6515        '''
 6516
 6517    def __repr__(self):
 6518        return '<sdm.KubernetesBasicAuth ' + \
 6519            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6520            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6521            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6522            'healthy: ' + repr(self.healthy) + ' ' +\
 6523            'hostname: ' + repr(self.hostname) + ' ' +\
 6524            'id: ' + repr(self.id) + ' ' +\
 6525            'name: ' + repr(self.name) + ' ' +\
 6526            'password: ' + repr(self.password) + ' ' +\
 6527            'port: ' + repr(self.port) + ' ' +\
 6528            'port_override: ' + repr(self.port_override) + ' ' +\
 6529            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6530            'tags: ' + repr(self.tags) + ' ' +\
 6531            'username: ' + repr(self.username) + ' ' +\
 6532            '>'
 6533
 6534    def to_dict(self):
 6535        return {
 6536            'bind_interface': self.bind_interface,
 6537            'egress_filter': self.egress_filter,
 6538            'healthcheck_namespace': self.healthcheck_namespace,
 6539            'healthy': self.healthy,
 6540            'hostname': self.hostname,
 6541            'id': self.id,
 6542            'name': self.name,
 6543            'password': self.password,
 6544            'port': self.port,
 6545            'port_override': self.port_override,
 6546            'secret_store_id': self.secret_store_id,
 6547            'tags': self.tags,
 6548            'username': self.username,
 6549        }
 6550
 6551    @classmethod
 6552    def from_dict(cls, d):
 6553        return cls(
 6554            bind_interface=d.get('bind_interface'),
 6555            egress_filter=d.get('egress_filter'),
 6556            healthcheck_namespace=d.get('healthcheck_namespace'),
 6557            healthy=d.get('healthy'),
 6558            hostname=d.get('hostname'),
 6559            id=d.get('id'),
 6560            name=d.get('name'),
 6561            password=d.get('password'),
 6562            port=d.get('port'),
 6563            port_override=d.get('port_override'),
 6564            secret_store_id=d.get('secret_store_id'),
 6565            tags=d.get('tags'),
 6566            username=d.get('username'),
 6567        )
 6568
 6569
 6570class KubernetesServiceAccount:
 6571    '''
 6572
 6573    '''
 6574    __slots__ = [
 6575        'bind_interface',
 6576        'egress_filter',
 6577        'healthcheck_namespace',
 6578        'healthy',
 6579        'hostname',
 6580        'id',
 6581        'name',
 6582        'port',
 6583        'port_override',
 6584        'remote_identity_group_id',
 6585        'remote_identity_healthcheck_username',
 6586        'secret_store_id',
 6587        'tags',
 6588        'token',
 6589    ]
 6590
 6591    def __init__(
 6592        self,
 6593        bind_interface=None,
 6594        egress_filter=None,
 6595        healthcheck_namespace=None,
 6596        healthy=None,
 6597        hostname=None,
 6598        id=None,
 6599        name=None,
 6600        port=None,
 6601        port_override=None,
 6602        remote_identity_group_id=None,
 6603        remote_identity_healthcheck_username=None,
 6604        secret_store_id=None,
 6605        tags=None,
 6606        token=None,
 6607    ):
 6608        self.bind_interface = bind_interface if bind_interface is not None else ''
 6609        '''
 6610         Bind interface
 6611        '''
 6612        self.egress_filter = egress_filter if egress_filter is not None else ''
 6613        '''
 6614         A filter applied to the routing logic to pin datasource to nodes.
 6615        '''
 6616        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6617        '''
 6618         The path used to check the health of your connection.  Defaults to `default`.
 6619        '''
 6620        self.healthy = healthy if healthy is not None else False
 6621        '''
 6622         True if the datasource is reachable and the credentials are valid.
 6623        '''
 6624        self.hostname = hostname if hostname is not None else ''
 6625        '''
 6626
 6627        '''
 6628        self.id = id if id is not None else ''
 6629        '''
 6630         Unique identifier of the Resource.
 6631        '''
 6632        self.name = name if name is not None else ''
 6633        '''
 6634         Unique human-readable name of the Resource.
 6635        '''
 6636        self.port = port if port is not None else 0
 6637        '''
 6638
 6639        '''
 6640        self.port_override = port_override if port_override is not None else 0
 6641        '''
 6642
 6643        '''
 6644        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 6645        '''
 6646
 6647        '''
 6648        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 6649        '''
 6650
 6651        '''
 6652        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6653        '''
 6654         ID of the secret store containing credentials for this resource, if any.
 6655        '''
 6656        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6657        '''
 6658         Tags is a map of key, value pairs.
 6659        '''
 6660        self.token = token if token is not None else ''
 6661        '''
 6662
 6663        '''
 6664
 6665    def __repr__(self):
 6666        return '<sdm.KubernetesServiceAccount ' + \
 6667            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6668            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6669            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6670            'healthy: ' + repr(self.healthy) + ' ' +\
 6671            'hostname: ' + repr(self.hostname) + ' ' +\
 6672            'id: ' + repr(self.id) + ' ' +\
 6673            'name: ' + repr(self.name) + ' ' +\
 6674            'port: ' + repr(self.port) + ' ' +\
 6675            'port_override: ' + repr(self.port_override) + ' ' +\
 6676            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 6677            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 6678            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6679            'tags: ' + repr(self.tags) + ' ' +\
 6680            'token: ' + repr(self.token) + ' ' +\
 6681            '>'
 6682
 6683    def to_dict(self):
 6684        return {
 6685            'bind_interface': self.bind_interface,
 6686            'egress_filter': self.egress_filter,
 6687            'healthcheck_namespace': self.healthcheck_namespace,
 6688            'healthy': self.healthy,
 6689            'hostname': self.hostname,
 6690            'id': self.id,
 6691            'name': self.name,
 6692            'port': self.port,
 6693            'port_override': self.port_override,
 6694            'remote_identity_group_id': self.remote_identity_group_id,
 6695            'remote_identity_healthcheck_username':
 6696            self.remote_identity_healthcheck_username,
 6697            'secret_store_id': self.secret_store_id,
 6698            'tags': self.tags,
 6699            'token': self.token,
 6700        }
 6701
 6702    @classmethod
 6703    def from_dict(cls, d):
 6704        return cls(
 6705            bind_interface=d.get('bind_interface'),
 6706            egress_filter=d.get('egress_filter'),
 6707            healthcheck_namespace=d.get('healthcheck_namespace'),
 6708            healthy=d.get('healthy'),
 6709            hostname=d.get('hostname'),
 6710            id=d.get('id'),
 6711            name=d.get('name'),
 6712            port=d.get('port'),
 6713            port_override=d.get('port_override'),
 6714            remote_identity_group_id=d.get('remote_identity_group_id'),
 6715            remote_identity_healthcheck_username=d.get(
 6716                'remote_identity_healthcheck_username'),
 6717            secret_store_id=d.get('secret_store_id'),
 6718            tags=d.get('tags'),
 6719            token=d.get('token'),
 6720        )
 6721
 6722
 6723class KubernetesServiceAccountUserImpersonation:
 6724    '''
 6725
 6726    '''
 6727    __slots__ = [
 6728        'bind_interface',
 6729        'egress_filter',
 6730        'healthcheck_namespace',
 6731        'healthy',
 6732        'hostname',
 6733        'id',
 6734        'name',
 6735        'port',
 6736        'port_override',
 6737        'secret_store_id',
 6738        'tags',
 6739        'token',
 6740    ]
 6741
 6742    def __init__(
 6743        self,
 6744        bind_interface=None,
 6745        egress_filter=None,
 6746        healthcheck_namespace=None,
 6747        healthy=None,
 6748        hostname=None,
 6749        id=None,
 6750        name=None,
 6751        port=None,
 6752        port_override=None,
 6753        secret_store_id=None,
 6754        tags=None,
 6755        token=None,
 6756    ):
 6757        self.bind_interface = bind_interface if bind_interface is not None else ''
 6758        '''
 6759         Bind interface
 6760        '''
 6761        self.egress_filter = egress_filter if egress_filter is not None else ''
 6762        '''
 6763         A filter applied to the routing logic to pin datasource to nodes.
 6764        '''
 6765        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6766        '''
 6767         The path used to check the health of your connection.  Defaults to `default`.
 6768        '''
 6769        self.healthy = healthy if healthy is not None else False
 6770        '''
 6771         True if the datasource is reachable and the credentials are valid.
 6772        '''
 6773        self.hostname = hostname if hostname is not None else ''
 6774        '''
 6775
 6776        '''
 6777        self.id = id if id is not None else ''
 6778        '''
 6779         Unique identifier of the Resource.
 6780        '''
 6781        self.name = name if name is not None else ''
 6782        '''
 6783         Unique human-readable name of the Resource.
 6784        '''
 6785        self.port = port if port is not None else 0
 6786        '''
 6787
 6788        '''
 6789        self.port_override = port_override if port_override is not None else 0
 6790        '''
 6791
 6792        '''
 6793        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6794        '''
 6795         ID of the secret store containing credentials for this resource, if any.
 6796        '''
 6797        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6798        '''
 6799         Tags is a map of key, value pairs.
 6800        '''
 6801        self.token = token if token is not None else ''
 6802        '''
 6803
 6804        '''
 6805
 6806    def __repr__(self):
 6807        return '<sdm.KubernetesServiceAccountUserImpersonation ' + \
 6808            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6809            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6810            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6811            'healthy: ' + repr(self.healthy) + ' ' +\
 6812            'hostname: ' + repr(self.hostname) + ' ' +\
 6813            'id: ' + repr(self.id) + ' ' +\
 6814            'name: ' + repr(self.name) + ' ' +\
 6815            'port: ' + repr(self.port) + ' ' +\
 6816            'port_override: ' + repr(self.port_override) + ' ' +\
 6817            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6818            'tags: ' + repr(self.tags) + ' ' +\
 6819            'token: ' + repr(self.token) + ' ' +\
 6820            '>'
 6821
 6822    def to_dict(self):
 6823        return {
 6824            'bind_interface': self.bind_interface,
 6825            'egress_filter': self.egress_filter,
 6826            'healthcheck_namespace': self.healthcheck_namespace,
 6827            'healthy': self.healthy,
 6828            'hostname': self.hostname,
 6829            'id': self.id,
 6830            'name': self.name,
 6831            'port': self.port,
 6832            'port_override': self.port_override,
 6833            'secret_store_id': self.secret_store_id,
 6834            'tags': self.tags,
 6835            'token': self.token,
 6836        }
 6837
 6838    @classmethod
 6839    def from_dict(cls, d):
 6840        return cls(
 6841            bind_interface=d.get('bind_interface'),
 6842            egress_filter=d.get('egress_filter'),
 6843            healthcheck_namespace=d.get('healthcheck_namespace'),
 6844            healthy=d.get('healthy'),
 6845            hostname=d.get('hostname'),
 6846            id=d.get('id'),
 6847            name=d.get('name'),
 6848            port=d.get('port'),
 6849            port_override=d.get('port_override'),
 6850            secret_store_id=d.get('secret_store_id'),
 6851            tags=d.get('tags'),
 6852            token=d.get('token'),
 6853        )
 6854
 6855
 6856class KubernetesUserImpersonation:
 6857    '''
 6858
 6859    '''
 6860    __slots__ = [
 6861        'bind_interface',
 6862        'certificate_authority',
 6863        'client_certificate',
 6864        'client_key',
 6865        'egress_filter',
 6866        'healthcheck_namespace',
 6867        'healthy',
 6868        'hostname',
 6869        'id',
 6870        'name',
 6871        'port',
 6872        'port_override',
 6873        'secret_store_id',
 6874        'tags',
 6875    ]
 6876
 6877    def __init__(
 6878        self,
 6879        bind_interface=None,
 6880        certificate_authority=None,
 6881        client_certificate=None,
 6882        client_key=None,
 6883        egress_filter=None,
 6884        healthcheck_namespace=None,
 6885        healthy=None,
 6886        hostname=None,
 6887        id=None,
 6888        name=None,
 6889        port=None,
 6890        port_override=None,
 6891        secret_store_id=None,
 6892        tags=None,
 6893    ):
 6894        self.bind_interface = bind_interface if bind_interface is not None else ''
 6895        '''
 6896         Bind interface
 6897        '''
 6898        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6899        '''
 6900
 6901        '''
 6902        self.client_certificate = client_certificate if client_certificate is not None else ''
 6903        '''
 6904
 6905        '''
 6906        self.client_key = client_key if client_key is not None else ''
 6907        '''
 6908
 6909        '''
 6910        self.egress_filter = egress_filter if egress_filter is not None else ''
 6911        '''
 6912         A filter applied to the routing logic to pin datasource to nodes.
 6913        '''
 6914        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6915        '''
 6916         The path used to check the health of your connection.  Defaults to `default`.
 6917        '''
 6918        self.healthy = healthy if healthy is not None else False
 6919        '''
 6920         True if the datasource is reachable and the credentials are valid.
 6921        '''
 6922        self.hostname = hostname if hostname is not None else ''
 6923        '''
 6924
 6925        '''
 6926        self.id = id if id is not None else ''
 6927        '''
 6928         Unique identifier of the Resource.
 6929        '''
 6930        self.name = name if name is not None else ''
 6931        '''
 6932         Unique human-readable name of the Resource.
 6933        '''
 6934        self.port = port if port is not None else 0
 6935        '''
 6936
 6937        '''
 6938        self.port_override = port_override if port_override is not None else 0
 6939        '''
 6940
 6941        '''
 6942        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6943        '''
 6944         ID of the secret store containing credentials for this resource, if any.
 6945        '''
 6946        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6947        '''
 6948         Tags is a map of key, value pairs.
 6949        '''
 6950
 6951    def __repr__(self):
 6952        return '<sdm.KubernetesUserImpersonation ' + \
 6953            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6954            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 6955            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 6956            'client_key: ' + repr(self.client_key) + ' ' +\
 6957            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6958            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6959            'healthy: ' + repr(self.healthy) + ' ' +\
 6960            'hostname: ' + repr(self.hostname) + ' ' +\
 6961            'id: ' + repr(self.id) + ' ' +\
 6962            'name: ' + repr(self.name) + ' ' +\
 6963            'port: ' + repr(self.port) + ' ' +\
 6964            'port_override: ' + repr(self.port_override) + ' ' +\
 6965            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6966            'tags: ' + repr(self.tags) + ' ' +\
 6967            '>'
 6968
 6969    def to_dict(self):
 6970        return {
 6971            'bind_interface': self.bind_interface,
 6972            'certificate_authority': self.certificate_authority,
 6973            'client_certificate': self.client_certificate,
 6974            'client_key': self.client_key,
 6975            'egress_filter': self.egress_filter,
 6976            'healthcheck_namespace': self.healthcheck_namespace,
 6977            'healthy': self.healthy,
 6978            'hostname': self.hostname,
 6979            'id': self.id,
 6980            'name': self.name,
 6981            'port': self.port,
 6982            'port_override': self.port_override,
 6983            'secret_store_id': self.secret_store_id,
 6984            'tags': self.tags,
 6985        }
 6986
 6987    @classmethod
 6988    def from_dict(cls, d):
 6989        return cls(
 6990            bind_interface=d.get('bind_interface'),
 6991            certificate_authority=d.get('certificate_authority'),
 6992            client_certificate=d.get('client_certificate'),
 6993            client_key=d.get('client_key'),
 6994            egress_filter=d.get('egress_filter'),
 6995            healthcheck_namespace=d.get('healthcheck_namespace'),
 6996            healthy=d.get('healthy'),
 6997            hostname=d.get('hostname'),
 6998            id=d.get('id'),
 6999            name=d.get('name'),
 7000            port=d.get('port'),
 7001            port_override=d.get('port_override'),
 7002            secret_store_id=d.get('secret_store_id'),
 7003            tags=d.get('tags'),
 7004        )
 7005
 7006
 7007class MTLSMysql:
 7008    '''
 7009
 7010    '''
 7011    __slots__ = [
 7012        'bind_interface',
 7013        'certificate_authority',
 7014        'client_certificate',
 7015        'client_key',
 7016        'database',
 7017        'egress_filter',
 7018        'healthy',
 7019        'hostname',
 7020        'id',
 7021        'name',
 7022        'password',
 7023        'port',
 7024        'port_override',
 7025        'secret_store_id',
 7026        'server_name',
 7027        'tags',
 7028        'username',
 7029    ]
 7030
 7031    def __init__(
 7032        self,
 7033        bind_interface=None,
 7034        certificate_authority=None,
 7035        client_certificate=None,
 7036        client_key=None,
 7037        database=None,
 7038        egress_filter=None,
 7039        healthy=None,
 7040        hostname=None,
 7041        id=None,
 7042        name=None,
 7043        password=None,
 7044        port=None,
 7045        port_override=None,
 7046        secret_store_id=None,
 7047        server_name=None,
 7048        tags=None,
 7049        username=None,
 7050    ):
 7051        self.bind_interface = bind_interface if bind_interface is not None else ''
 7052        '''
 7053         Bind interface
 7054        '''
 7055        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 7056        '''
 7057
 7058        '''
 7059        self.client_certificate = client_certificate if client_certificate is not None else ''
 7060        '''
 7061
 7062        '''
 7063        self.client_key = client_key if client_key is not None else ''
 7064        '''
 7065
 7066        '''
 7067        self.database = database if database is not None else ''
 7068        '''
 7069
 7070        '''
 7071        self.egress_filter = egress_filter if egress_filter is not None else ''
 7072        '''
 7073         A filter applied to the routing logic to pin datasource to nodes.
 7074        '''
 7075        self.healthy = healthy if healthy is not None else False
 7076        '''
 7077         True if the datasource is reachable and the credentials are valid.
 7078        '''
 7079        self.hostname = hostname if hostname is not None else ''
 7080        '''
 7081
 7082        '''
 7083        self.id = id if id is not None else ''
 7084        '''
 7085         Unique identifier of the Resource.
 7086        '''
 7087        self.name = name if name is not None else ''
 7088        '''
 7089         Unique human-readable name of the Resource.
 7090        '''
 7091        self.password = password if password is not None else ''
 7092        '''
 7093
 7094        '''
 7095        self.port = port if port is not None else 0
 7096        '''
 7097
 7098        '''
 7099        self.port_override = port_override if port_override is not None else 0
 7100        '''
 7101
 7102        '''
 7103        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7104        '''
 7105         ID of the secret store containing credentials for this resource, if any.
 7106        '''
 7107        self.server_name = server_name if server_name is not None else ''
 7108        '''
 7109
 7110        '''
 7111        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7112        '''
 7113         Tags is a map of key, value pairs.
 7114        '''
 7115        self.username = username if username is not None else ''
 7116        '''
 7117
 7118        '''
 7119
 7120    def __repr__(self):
 7121        return '<sdm.MTLSMysql ' + \
 7122            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7123            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 7124            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 7125            'client_key: ' + repr(self.client_key) + ' ' +\
 7126            'database: ' + repr(self.database) + ' ' +\
 7127            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7128            'healthy: ' + repr(self.healthy) + ' ' +\
 7129            'hostname: ' + repr(self.hostname) + ' ' +\
 7130            'id: ' + repr(self.id) + ' ' +\
 7131            'name: ' + repr(self.name) + ' ' +\
 7132            'password: ' + repr(self.password) + ' ' +\
 7133            'port: ' + repr(self.port) + ' ' +\
 7134            'port_override: ' + repr(self.port_override) + ' ' +\
 7135            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7136            'server_name: ' + repr(self.server_name) + ' ' +\
 7137            'tags: ' + repr(self.tags) + ' ' +\
 7138            'username: ' + repr(self.username) + ' ' +\
 7139            '>'
 7140
 7141    def to_dict(self):
 7142        return {
 7143            'bind_interface': self.bind_interface,
 7144            'certificate_authority': self.certificate_authority,
 7145            'client_certificate': self.client_certificate,
 7146            'client_key': self.client_key,
 7147            'database': self.database,
 7148            'egress_filter': self.egress_filter,
 7149            'healthy': self.healthy,
 7150            'hostname': self.hostname,
 7151            'id': self.id,
 7152            'name': self.name,
 7153            'password': self.password,
 7154            'port': self.port,
 7155            'port_override': self.port_override,
 7156            'secret_store_id': self.secret_store_id,
 7157            'server_name': self.server_name,
 7158            'tags': self.tags,
 7159            'username': self.username,
 7160        }
 7161
 7162    @classmethod
 7163    def from_dict(cls, d):
 7164        return cls(
 7165            bind_interface=d.get('bind_interface'),
 7166            certificate_authority=d.get('certificate_authority'),
 7167            client_certificate=d.get('client_certificate'),
 7168            client_key=d.get('client_key'),
 7169            database=d.get('database'),
 7170            egress_filter=d.get('egress_filter'),
 7171            healthy=d.get('healthy'),
 7172            hostname=d.get('hostname'),
 7173            id=d.get('id'),
 7174            name=d.get('name'),
 7175            password=d.get('password'),
 7176            port=d.get('port'),
 7177            port_override=d.get('port_override'),
 7178            secret_store_id=d.get('secret_store_id'),
 7179            server_name=d.get('server_name'),
 7180            tags=d.get('tags'),
 7181            username=d.get('username'),
 7182        )
 7183
 7184
 7185class MTLSPostgres:
 7186    '''
 7187
 7188    '''
 7189    __slots__ = [
 7190        'bind_interface',
 7191        'certificate_authority',
 7192        'client_certificate',
 7193        'client_key',
 7194        'database',
 7195        'egress_filter',
 7196        'healthy',
 7197        'hostname',
 7198        'id',
 7199        'name',
 7200        'override_database',
 7201        'password',
 7202        'port',
 7203        'port_override',
 7204        'secret_store_id',
 7205        'server_name',
 7206        'tags',
 7207        'username',
 7208    ]
 7209
 7210    def __init__(
 7211        self,
 7212        bind_interface=None,
 7213        certificate_authority=None,
 7214        client_certificate=None,
 7215        client_key=None,
 7216        database=None,
 7217        egress_filter=None,
 7218        healthy=None,
 7219        hostname=None,
 7220        id=None,
 7221        name=None,
 7222        override_database=None,
 7223        password=None,
 7224        port=None,
 7225        port_override=None,
 7226        secret_store_id=None,
 7227        server_name=None,
 7228        tags=None,
 7229        username=None,
 7230    ):
 7231        self.bind_interface = bind_interface if bind_interface is not None else ''
 7232        '''
 7233         Bind interface
 7234        '''
 7235        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 7236        '''
 7237
 7238        '''
 7239        self.client_certificate = client_certificate if client_certificate is not None else ''
 7240        '''
 7241
 7242        '''
 7243        self.client_key = client_key if client_key is not None else ''
 7244        '''
 7245
 7246        '''
 7247        self.database = database if database is not None else ''
 7248        '''
 7249
 7250        '''
 7251        self.egress_filter = egress_filter if egress_filter is not None else ''
 7252        '''
 7253         A filter applied to the routing logic to pin datasource to nodes.
 7254        '''
 7255        self.healthy = healthy if healthy is not None else False
 7256        '''
 7257         True if the datasource is reachable and the credentials are valid.
 7258        '''
 7259        self.hostname = hostname if hostname is not None else ''
 7260        '''
 7261
 7262        '''
 7263        self.id = id if id is not None else ''
 7264        '''
 7265         Unique identifier of the Resource.
 7266        '''
 7267        self.name = name if name is not None else ''
 7268        '''
 7269         Unique human-readable name of the Resource.
 7270        '''
 7271        self.override_database = override_database if override_database is not None else False
 7272        '''
 7273
 7274        '''
 7275        self.password = password if password is not None else ''
 7276        '''
 7277
 7278        '''
 7279        self.port = port if port is not None else 0
 7280        '''
 7281
 7282        '''
 7283        self.port_override = port_override if port_override is not None else 0
 7284        '''
 7285
 7286        '''
 7287        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7288        '''
 7289         ID of the secret store containing credentials for this resource, if any.
 7290        '''
 7291        self.server_name = server_name if server_name is not None else ''
 7292        '''
 7293
 7294        '''
 7295        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7296        '''
 7297         Tags is a map of key, value pairs.
 7298        '''
 7299        self.username = username if username is not None else ''
 7300        '''
 7301
 7302        '''
 7303
 7304    def __repr__(self):
 7305        return '<sdm.MTLSPostgres ' + \
 7306            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7307            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 7308            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 7309            'client_key: ' + repr(self.client_key) + ' ' +\
 7310            'database: ' + repr(self.database) + ' ' +\
 7311            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7312            'healthy: ' + repr(self.healthy) + ' ' +\
 7313            'hostname: ' + repr(self.hostname) + ' ' +\
 7314            'id: ' + repr(self.id) + ' ' +\
 7315            'name: ' + repr(self.name) + ' ' +\
 7316            'override_database: ' + repr(self.override_database) + ' ' +\
 7317            'password: ' + repr(self.password) + ' ' +\
 7318            'port: ' + repr(self.port) + ' ' +\
 7319            'port_override: ' + repr(self.port_override) + ' ' +\
 7320            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7321            'server_name: ' + repr(self.server_name) + ' ' +\
 7322            'tags: ' + repr(self.tags) + ' ' +\
 7323            'username: ' + repr(self.username) + ' ' +\
 7324            '>'
 7325
 7326    def to_dict(self):
 7327        return {
 7328            'bind_interface': self.bind_interface,
 7329            'certificate_authority': self.certificate_authority,
 7330            'client_certificate': self.client_certificate,
 7331            'client_key': self.client_key,
 7332            'database': self.database,
 7333            'egress_filter': self.egress_filter,
 7334            'healthy': self.healthy,
 7335            'hostname': self.hostname,
 7336            'id': self.id,
 7337            'name': self.name,
 7338            'override_database': self.override_database,
 7339            'password': self.password,
 7340            'port': self.port,
 7341            'port_override': self.port_override,
 7342            'secret_store_id': self.secret_store_id,
 7343            'server_name': self.server_name,
 7344            'tags': self.tags,
 7345            'username': self.username,
 7346        }
 7347
 7348    @classmethod
 7349    def from_dict(cls, d):
 7350        return cls(
 7351            bind_interface=d.get('bind_interface'),
 7352            certificate_authority=d.get('certificate_authority'),
 7353            client_certificate=d.get('client_certificate'),
 7354            client_key=d.get('client_key'),
 7355            database=d.get('database'),
 7356            egress_filter=d.get('egress_filter'),
 7357            healthy=d.get('healthy'),
 7358            hostname=d.get('hostname'),
 7359            id=d.get('id'),
 7360            name=d.get('name'),
 7361            override_database=d.get('override_database'),
 7362            password=d.get('password'),
 7363            port=d.get('port'),
 7364            port_override=d.get('port_override'),
 7365            secret_store_id=d.get('secret_store_id'),
 7366            server_name=d.get('server_name'),
 7367            tags=d.get('tags'),
 7368            username=d.get('username'),
 7369        )
 7370
 7371
 7372class Maria:
 7373    '''
 7374
 7375    '''
 7376    __slots__ = [
 7377        'bind_interface',
 7378        'database',
 7379        'egress_filter',
 7380        'healthy',
 7381        'hostname',
 7382        'id',
 7383        'name',
 7384        'password',
 7385        'port',
 7386        'port_override',
 7387        'secret_store_id',
 7388        'tags',
 7389        'username',
 7390    ]
 7391
 7392    def __init__(
 7393        self,
 7394        bind_interface=None,
 7395        database=None,
 7396        egress_filter=None,
 7397        healthy=None,
 7398        hostname=None,
 7399        id=None,
 7400        name=None,
 7401        password=None,
 7402        port=None,
 7403        port_override=None,
 7404        secret_store_id=None,
 7405        tags=None,
 7406        username=None,
 7407    ):
 7408        self.bind_interface = bind_interface if bind_interface is not None else ''
 7409        '''
 7410         Bind interface
 7411        '''
 7412        self.database = database if database is not None else ''
 7413        '''
 7414
 7415        '''
 7416        self.egress_filter = egress_filter if egress_filter is not None else ''
 7417        '''
 7418         A filter applied to the routing logic to pin datasource to nodes.
 7419        '''
 7420        self.healthy = healthy if healthy is not None else False
 7421        '''
 7422         True if the datasource is reachable and the credentials are valid.
 7423        '''
 7424        self.hostname = hostname if hostname is not None else ''
 7425        '''
 7426
 7427        '''
 7428        self.id = id if id is not None else ''
 7429        '''
 7430         Unique identifier of the Resource.
 7431        '''
 7432        self.name = name if name is not None else ''
 7433        '''
 7434         Unique human-readable name of the Resource.
 7435        '''
 7436        self.password = password if password is not None else ''
 7437        '''
 7438
 7439        '''
 7440        self.port = port if port is not None else 0
 7441        '''
 7442
 7443        '''
 7444        self.port_override = port_override if port_override is not None else 0
 7445        '''
 7446
 7447        '''
 7448        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7449        '''
 7450         ID of the secret store containing credentials for this resource, if any.
 7451        '''
 7452        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7453        '''
 7454         Tags is a map of key, value pairs.
 7455        '''
 7456        self.username = username if username is not None else ''
 7457        '''
 7458
 7459        '''
 7460
 7461    def __repr__(self):
 7462        return '<sdm.Maria ' + \
 7463            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7464            'database: ' + repr(self.database) + ' ' +\
 7465            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7466            'healthy: ' + repr(self.healthy) + ' ' +\
 7467            'hostname: ' + repr(self.hostname) + ' ' +\
 7468            'id: ' + repr(self.id) + ' ' +\
 7469            'name: ' + repr(self.name) + ' ' +\
 7470            'password: ' + repr(self.password) + ' ' +\
 7471            'port: ' + repr(self.port) + ' ' +\
 7472            'port_override: ' + repr(self.port_override) + ' ' +\
 7473            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7474            'tags: ' + repr(self.tags) + ' ' +\
 7475            'username: ' + repr(self.username) + ' ' +\
 7476            '>'
 7477
 7478    def to_dict(self):
 7479        return {
 7480            'bind_interface': self.bind_interface,
 7481            'database': self.database,
 7482            'egress_filter': self.egress_filter,
 7483            'healthy': self.healthy,
 7484            'hostname': self.hostname,
 7485            'id': self.id,
 7486            'name': self.name,
 7487            'password': self.password,
 7488            'port': self.port,
 7489            'port_override': self.port_override,
 7490            'secret_store_id': self.secret_store_id,
 7491            'tags': self.tags,
 7492            'username': self.username,
 7493        }
 7494
 7495    @classmethod
 7496    def from_dict(cls, d):
 7497        return cls(
 7498            bind_interface=d.get('bind_interface'),
 7499            database=d.get('database'),
 7500            egress_filter=d.get('egress_filter'),
 7501            healthy=d.get('healthy'),
 7502            hostname=d.get('hostname'),
 7503            id=d.get('id'),
 7504            name=d.get('name'),
 7505            password=d.get('password'),
 7506            port=d.get('port'),
 7507            port_override=d.get('port_override'),
 7508            secret_store_id=d.get('secret_store_id'),
 7509            tags=d.get('tags'),
 7510            username=d.get('username'),
 7511        )
 7512
 7513
 7514class Memcached:
 7515    '''
 7516
 7517    '''
 7518    __slots__ = [
 7519        'bind_interface',
 7520        'egress_filter',
 7521        'healthy',
 7522        'hostname',
 7523        'id',
 7524        'name',
 7525        'port',
 7526        'port_override',
 7527        'secret_store_id',
 7528        'tags',
 7529    ]
 7530
 7531    def __init__(
 7532        self,
 7533        bind_interface=None,
 7534        egress_filter=None,
 7535        healthy=None,
 7536        hostname=None,
 7537        id=None,
 7538        name=None,
 7539        port=None,
 7540        port_override=None,
 7541        secret_store_id=None,
 7542        tags=None,
 7543    ):
 7544        self.bind_interface = bind_interface if bind_interface is not None else ''
 7545        '''
 7546         Bind interface
 7547        '''
 7548        self.egress_filter = egress_filter if egress_filter is not None else ''
 7549        '''
 7550         A filter applied to the routing logic to pin datasource to nodes.
 7551        '''
 7552        self.healthy = healthy if healthy is not None else False
 7553        '''
 7554         True if the datasource is reachable and the credentials are valid.
 7555        '''
 7556        self.hostname = hostname if hostname is not None else ''
 7557        '''
 7558
 7559        '''
 7560        self.id = id if id is not None else ''
 7561        '''
 7562         Unique identifier of the Resource.
 7563        '''
 7564        self.name = name if name is not None else ''
 7565        '''
 7566         Unique human-readable name of the Resource.
 7567        '''
 7568        self.port = port if port is not None else 0
 7569        '''
 7570
 7571        '''
 7572        self.port_override = port_override if port_override is not None else 0
 7573        '''
 7574
 7575        '''
 7576        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7577        '''
 7578         ID of the secret store containing credentials for this resource, if any.
 7579        '''
 7580        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7581        '''
 7582         Tags is a map of key, value pairs.
 7583        '''
 7584
 7585    def __repr__(self):
 7586        return '<sdm.Memcached ' + \
 7587            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7588            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7589            'healthy: ' + repr(self.healthy) + ' ' +\
 7590            'hostname: ' + repr(self.hostname) + ' ' +\
 7591            'id: ' + repr(self.id) + ' ' +\
 7592            'name: ' + repr(self.name) + ' ' +\
 7593            'port: ' + repr(self.port) + ' ' +\
 7594            'port_override: ' + repr(self.port_override) + ' ' +\
 7595            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7596            'tags: ' + repr(self.tags) + ' ' +\
 7597            '>'
 7598
 7599    def to_dict(self):
 7600        return {
 7601            'bind_interface': self.bind_interface,
 7602            'egress_filter': self.egress_filter,
 7603            'healthy': self.healthy,
 7604            'hostname': self.hostname,
 7605            'id': self.id,
 7606            'name': self.name,
 7607            'port': self.port,
 7608            'port_override': self.port_override,
 7609            'secret_store_id': self.secret_store_id,
 7610            'tags': self.tags,
 7611        }
 7612
 7613    @classmethod
 7614    def from_dict(cls, d):
 7615        return cls(
 7616            bind_interface=d.get('bind_interface'),
 7617            egress_filter=d.get('egress_filter'),
 7618            healthy=d.get('healthy'),
 7619            hostname=d.get('hostname'),
 7620            id=d.get('id'),
 7621            name=d.get('name'),
 7622            port=d.get('port'),
 7623            port_override=d.get('port_override'),
 7624            secret_store_id=d.get('secret_store_id'),
 7625            tags=d.get('tags'),
 7626        )
 7627
 7628
 7629class Memsql:
 7630    '''
 7631
 7632    '''
 7633    __slots__ = [
 7634        'bind_interface',
 7635        'database',
 7636        'egress_filter',
 7637        'healthy',
 7638        'hostname',
 7639        'id',
 7640        'name',
 7641        'password',
 7642        'port',
 7643        'port_override',
 7644        'secret_store_id',
 7645        'tags',
 7646        'username',
 7647    ]
 7648
 7649    def __init__(
 7650        self,
 7651        bind_interface=None,
 7652        database=None,
 7653        egress_filter=None,
 7654        healthy=None,
 7655        hostname=None,
 7656        id=None,
 7657        name=None,
 7658        password=None,
 7659        port=None,
 7660        port_override=None,
 7661        secret_store_id=None,
 7662        tags=None,
 7663        username=None,
 7664    ):
 7665        self.bind_interface = bind_interface if bind_interface is not None else ''
 7666        '''
 7667         Bind interface
 7668        '''
 7669        self.database = database if database is not None else ''
 7670        '''
 7671
 7672        '''
 7673        self.egress_filter = egress_filter if egress_filter is not None else ''
 7674        '''
 7675         A filter applied to the routing logic to pin datasource to nodes.
 7676        '''
 7677        self.healthy = healthy if healthy is not None else False
 7678        '''
 7679         True if the datasource is reachable and the credentials are valid.
 7680        '''
 7681        self.hostname = hostname if hostname is not None else ''
 7682        '''
 7683
 7684        '''
 7685        self.id = id if id is not None else ''
 7686        '''
 7687         Unique identifier of the Resource.
 7688        '''
 7689        self.name = name if name is not None else ''
 7690        '''
 7691         Unique human-readable name of the Resource.
 7692        '''
 7693        self.password = password if password is not None else ''
 7694        '''
 7695
 7696        '''
 7697        self.port = port if port is not None else 0
 7698        '''
 7699
 7700        '''
 7701        self.port_override = port_override if port_override is not None else 0
 7702        '''
 7703
 7704        '''
 7705        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7706        '''
 7707         ID of the secret store containing credentials for this resource, if any.
 7708        '''
 7709        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7710        '''
 7711         Tags is a map of key, value pairs.
 7712        '''
 7713        self.username = username if username is not None else ''
 7714        '''
 7715
 7716        '''
 7717
 7718    def __repr__(self):
 7719        return '<sdm.Memsql ' + \
 7720            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7721            'database: ' + repr(self.database) + ' ' +\
 7722            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7723            'healthy: ' + repr(self.healthy) + ' ' +\
 7724            'hostname: ' + repr(self.hostname) + ' ' +\
 7725            'id: ' + repr(self.id) + ' ' +\
 7726            'name: ' + repr(self.name) + ' ' +\
 7727            'password: ' + repr(self.password) + ' ' +\
 7728            'port: ' + repr(self.port) + ' ' +\
 7729            'port_override: ' + repr(self.port_override) + ' ' +\
 7730            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7731            'tags: ' + repr(self.tags) + ' ' +\
 7732            'username: ' + repr(self.username) + ' ' +\
 7733            '>'
 7734
 7735    def to_dict(self):
 7736        return {
 7737            'bind_interface': self.bind_interface,
 7738            'database': self.database,
 7739            'egress_filter': self.egress_filter,
 7740            'healthy': self.healthy,
 7741            'hostname': self.hostname,
 7742            'id': self.id,
 7743            'name': self.name,
 7744            'password': self.password,
 7745            'port': self.port,
 7746            'port_override': self.port_override,
 7747            'secret_store_id': self.secret_store_id,
 7748            'tags': self.tags,
 7749            'username': self.username,
 7750        }
 7751
 7752    @classmethod
 7753    def from_dict(cls, d):
 7754        return cls(
 7755            bind_interface=d.get('bind_interface'),
 7756            database=d.get('database'),
 7757            egress_filter=d.get('egress_filter'),
 7758            healthy=d.get('healthy'),
 7759            hostname=d.get('hostname'),
 7760            id=d.get('id'),
 7761            name=d.get('name'),
 7762            password=d.get('password'),
 7763            port=d.get('port'),
 7764            port_override=d.get('port_override'),
 7765            secret_store_id=d.get('secret_store_id'),
 7766            tags=d.get('tags'),
 7767            username=d.get('username'),
 7768        )
 7769
 7770
 7771class MongoHost:
 7772    '''
 7773
 7774    '''
 7775    __slots__ = [
 7776        'auth_database',
 7777        'bind_interface',
 7778        'egress_filter',
 7779        'healthy',
 7780        'hostname',
 7781        'id',
 7782        'name',
 7783        'password',
 7784        'port',
 7785        'port_override',
 7786        'secret_store_id',
 7787        'tags',
 7788        'tls_required',
 7789        'username',
 7790    ]
 7791
 7792    def __init__(
 7793        self,
 7794        auth_database=None,
 7795        bind_interface=None,
 7796        egress_filter=None,
 7797        healthy=None,
 7798        hostname=None,
 7799        id=None,
 7800        name=None,
 7801        password=None,
 7802        port=None,
 7803        port_override=None,
 7804        secret_store_id=None,
 7805        tags=None,
 7806        tls_required=None,
 7807        username=None,
 7808    ):
 7809        self.auth_database = auth_database if auth_database is not None else ''
 7810        '''
 7811
 7812        '''
 7813        self.bind_interface = bind_interface if bind_interface is not None else ''
 7814        '''
 7815         Bind interface
 7816        '''
 7817        self.egress_filter = egress_filter if egress_filter is not None else ''
 7818        '''
 7819         A filter applied to the routing logic to pin datasource to nodes.
 7820        '''
 7821        self.healthy = healthy if healthy is not None else False
 7822        '''
 7823         True if the datasource is reachable and the credentials are valid.
 7824        '''
 7825        self.hostname = hostname if hostname is not None else ''
 7826        '''
 7827
 7828        '''
 7829        self.id = id if id is not None else ''
 7830        '''
 7831         Unique identifier of the Resource.
 7832        '''
 7833        self.name = name if name is not None else ''
 7834        '''
 7835         Unique human-readable name of the Resource.
 7836        '''
 7837        self.password = password if password is not None else ''
 7838        '''
 7839
 7840        '''
 7841        self.port = port if port is not None else 0
 7842        '''
 7843
 7844        '''
 7845        self.port_override = port_override if port_override is not None else 0
 7846        '''
 7847
 7848        '''
 7849        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7850        '''
 7851         ID of the secret store containing credentials for this resource, if any.
 7852        '''
 7853        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7854        '''
 7855         Tags is a map of key, value pairs.
 7856        '''
 7857        self.tls_required = tls_required if tls_required is not None else False
 7858        '''
 7859
 7860        '''
 7861        self.username = username if username is not None else ''
 7862        '''
 7863
 7864        '''
 7865
 7866    def __repr__(self):
 7867        return '<sdm.MongoHost ' + \
 7868            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7869            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7870            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7871            'healthy: ' + repr(self.healthy) + ' ' +\
 7872            'hostname: ' + repr(self.hostname) + ' ' +\
 7873            'id: ' + repr(self.id) + ' ' +\
 7874            'name: ' + repr(self.name) + ' ' +\
 7875            'password: ' + repr(self.password) + ' ' +\
 7876            'port: ' + repr(self.port) + ' ' +\
 7877            'port_override: ' + repr(self.port_override) + ' ' +\
 7878            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7879            'tags: ' + repr(self.tags) + ' ' +\
 7880            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7881            'username: ' + repr(self.username) + ' ' +\
 7882            '>'
 7883
 7884    def to_dict(self):
 7885        return {
 7886            'auth_database': self.auth_database,
 7887            'bind_interface': self.bind_interface,
 7888            'egress_filter': self.egress_filter,
 7889            'healthy': self.healthy,
 7890            'hostname': self.hostname,
 7891            'id': self.id,
 7892            'name': self.name,
 7893            'password': self.password,
 7894            'port': self.port,
 7895            'port_override': self.port_override,
 7896            'secret_store_id': self.secret_store_id,
 7897            'tags': self.tags,
 7898            'tls_required': self.tls_required,
 7899            'username': self.username,
 7900        }
 7901
 7902    @classmethod
 7903    def from_dict(cls, d):
 7904        return cls(
 7905            auth_database=d.get('auth_database'),
 7906            bind_interface=d.get('bind_interface'),
 7907            egress_filter=d.get('egress_filter'),
 7908            healthy=d.get('healthy'),
 7909            hostname=d.get('hostname'),
 7910            id=d.get('id'),
 7911            name=d.get('name'),
 7912            password=d.get('password'),
 7913            port=d.get('port'),
 7914            port_override=d.get('port_override'),
 7915            secret_store_id=d.get('secret_store_id'),
 7916            tags=d.get('tags'),
 7917            tls_required=d.get('tls_required'),
 7918            username=d.get('username'),
 7919        )
 7920
 7921
 7922class MongoLegacyHost:
 7923    '''
 7924
 7925    '''
 7926    __slots__ = [
 7927        'auth_database',
 7928        'bind_interface',
 7929        'egress_filter',
 7930        'healthy',
 7931        'hostname',
 7932        'id',
 7933        'name',
 7934        'password',
 7935        'port',
 7936        'port_override',
 7937        'replica_set',
 7938        'secret_store_id',
 7939        'tags',
 7940        'tls_required',
 7941        'username',
 7942    ]
 7943
 7944    def __init__(
 7945        self,
 7946        auth_database=None,
 7947        bind_interface=None,
 7948        egress_filter=None,
 7949        healthy=None,
 7950        hostname=None,
 7951        id=None,
 7952        name=None,
 7953        password=None,
 7954        port=None,
 7955        port_override=None,
 7956        replica_set=None,
 7957        secret_store_id=None,
 7958        tags=None,
 7959        tls_required=None,
 7960        username=None,
 7961    ):
 7962        self.auth_database = auth_database if auth_database is not None else ''
 7963        '''
 7964
 7965        '''
 7966        self.bind_interface = bind_interface if bind_interface is not None else ''
 7967        '''
 7968         Bind interface
 7969        '''
 7970        self.egress_filter = egress_filter if egress_filter is not None else ''
 7971        '''
 7972         A filter applied to the routing logic to pin datasource to nodes.
 7973        '''
 7974        self.healthy = healthy if healthy is not None else False
 7975        '''
 7976         True if the datasource is reachable and the credentials are valid.
 7977        '''
 7978        self.hostname = hostname if hostname is not None else ''
 7979        '''
 7980
 7981        '''
 7982        self.id = id if id is not None else ''
 7983        '''
 7984         Unique identifier of the Resource.
 7985        '''
 7986        self.name = name if name is not None else ''
 7987        '''
 7988         Unique human-readable name of the Resource.
 7989        '''
 7990        self.password = password if password is not None else ''
 7991        '''
 7992
 7993        '''
 7994        self.port = port if port is not None else 0
 7995        '''
 7996
 7997        '''
 7998        self.port_override = port_override if port_override is not None else 0
 7999        '''
 8000
 8001        '''
 8002        self.replica_set = replica_set if replica_set is not None else ''
 8003        '''
 8004
 8005        '''
 8006        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8007        '''
 8008         ID of the secret store containing credentials for this resource, if any.
 8009        '''
 8010        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8011        '''
 8012         Tags is a map of key, value pairs.
 8013        '''
 8014        self.tls_required = tls_required if tls_required is not None else False
 8015        '''
 8016
 8017        '''
 8018        self.username = username if username is not None else ''
 8019        '''
 8020
 8021        '''
 8022
 8023    def __repr__(self):
 8024        return '<sdm.MongoLegacyHost ' + \
 8025            'auth_database: ' + repr(self.auth_database) + ' ' +\
 8026            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8027            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8028            'healthy: ' + repr(self.healthy) + ' ' +\
 8029            'hostname: ' + repr(self.hostname) + ' ' +\
 8030            'id: ' + repr(self.id) + ' ' +\
 8031            'name: ' + repr(self.name) + ' ' +\
 8032            'password: ' + repr(self.password) + ' ' +\
 8033            'port: ' + repr(self.port) + ' ' +\
 8034            'port_override: ' + repr(self.port_override) + ' ' +\
 8035            'replica_set: ' + repr(self.replica_set) + ' ' +\
 8036            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8037            'tags: ' + repr(self.tags) + ' ' +\
 8038            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8039            'username: ' + repr(self.username) + ' ' +\
 8040            '>'
 8041
 8042    def to_dict(self):
 8043        return {
 8044            'auth_database': self.auth_database,
 8045            'bind_interface': self.bind_interface,
 8046            'egress_filter': self.egress_filter,
 8047            'healthy': self.healthy,
 8048            'hostname': self.hostname,
 8049            'id': self.id,
 8050            'name': self.name,
 8051            'password': self.password,
 8052            'port': self.port,
 8053            'port_override': self.port_override,
 8054            'replica_set': self.replica_set,
 8055            'secret_store_id': self.secret_store_id,
 8056            'tags': self.tags,
 8057            'tls_required': self.tls_required,
 8058            'username': self.username,
 8059        }
 8060
 8061    @classmethod
 8062    def from_dict(cls, d):
 8063        return cls(
 8064            auth_database=d.get('auth_database'),
 8065            bind_interface=d.get('bind_interface'),
 8066            egress_filter=d.get('egress_filter'),
 8067            healthy=d.get('healthy'),
 8068            hostname=d.get('hostname'),
 8069            id=d.get('id'),
 8070            name=d.get('name'),
 8071            password=d.get('password'),
 8072            port=d.get('port'),
 8073            port_override=d.get('port_override'),
 8074            replica_set=d.get('replica_set'),
 8075            secret_store_id=d.get('secret_store_id'),
 8076            tags=d.get('tags'),
 8077            tls_required=d.get('tls_required'),
 8078            username=d.get('username'),
 8079        )
 8080
 8081
 8082class MongoLegacyReplicaset:
 8083    '''
 8084
 8085    '''
 8086    __slots__ = [
 8087        'auth_database',
 8088        'bind_interface',
 8089        'connect_to_replica',
 8090        'egress_filter',
 8091        'healthy',
 8092        'hostname',
 8093        'id',
 8094        'name',
 8095        'password',
 8096        'port',
 8097        'port_override',
 8098        'replica_set',
 8099        'secret_store_id',
 8100        'tags',
 8101        'tls_required',
 8102        'username',
 8103    ]
 8104
 8105    def __init__(
 8106        self,
 8107        auth_database=None,
 8108        bind_interface=None,
 8109        connect_to_replica=None,
 8110        egress_filter=None,
 8111        healthy=None,
 8112        hostname=None,
 8113        id=None,
 8114        name=None,
 8115        password=None,
 8116        port=None,
 8117        port_override=None,
 8118        replica_set=None,
 8119        secret_store_id=None,
 8120        tags=None,
 8121        tls_required=None,
 8122        username=None,
 8123    ):
 8124        self.auth_database = auth_database if auth_database is not None else ''
 8125        '''
 8126
 8127        '''
 8128        self.bind_interface = bind_interface if bind_interface is not None else ''
 8129        '''
 8130         Bind interface
 8131        '''
 8132        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 8133        '''
 8134
 8135        '''
 8136        self.egress_filter = egress_filter if egress_filter is not None else ''
 8137        '''
 8138         A filter applied to the routing logic to pin datasource to nodes.
 8139        '''
 8140        self.healthy = healthy if healthy is not None else False
 8141        '''
 8142         True if the datasource is reachable and the credentials are valid.
 8143        '''
 8144        self.hostname = hostname if hostname is not None else ''
 8145        '''
 8146
 8147        '''
 8148        self.id = id if id is not None else ''
 8149        '''
 8150         Unique identifier of the Resource.
 8151        '''
 8152        self.name = name if name is not None else ''
 8153        '''
 8154         Unique human-readable name of the Resource.
 8155        '''
 8156        self.password = password if password is not None else ''
 8157        '''
 8158
 8159        '''
 8160        self.port = port if port is not None else 0
 8161        '''
 8162
 8163        '''
 8164        self.port_override = port_override if port_override is not None else 0
 8165        '''
 8166
 8167        '''
 8168        self.replica_set = replica_set if replica_set is not None else ''
 8169        '''
 8170
 8171        '''
 8172        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8173        '''
 8174         ID of the secret store containing credentials for this resource, if any.
 8175        '''
 8176        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8177        '''
 8178         Tags is a map of key, value pairs.
 8179        '''
 8180        self.tls_required = tls_required if tls_required is not None else False
 8181        '''
 8182
 8183        '''
 8184        self.username = username if username is not None else ''
 8185        '''
 8186
 8187        '''
 8188
 8189    def __repr__(self):
 8190        return '<sdm.MongoLegacyReplicaset ' + \
 8191            'auth_database: ' + repr(self.auth_database) + ' ' +\
 8192            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8193            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 8194            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8195            'healthy: ' + repr(self.healthy) + ' ' +\
 8196            'hostname: ' + repr(self.hostname) + ' ' +\
 8197            'id: ' + repr(self.id) + ' ' +\
 8198            'name: ' + repr(self.name) + ' ' +\
 8199            'password: ' + repr(self.password) + ' ' +\
 8200            'port: ' + repr(self.port) + ' ' +\
 8201            'port_override: ' + repr(self.port_override) + ' ' +\
 8202            'replica_set: ' + repr(self.replica_set) + ' ' +\
 8203            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8204            'tags: ' + repr(self.tags) + ' ' +\
 8205            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8206            'username: ' + repr(self.username) + ' ' +\
 8207            '>'
 8208
 8209    def to_dict(self):
 8210        return {
 8211            'auth_database': self.auth_database,
 8212            'bind_interface': self.bind_interface,
 8213            'connect_to_replica': self.connect_to_replica,
 8214            'egress_filter': self.egress_filter,
 8215            'healthy': self.healthy,
 8216            'hostname': self.hostname,
 8217            'id': self.id,
 8218            'name': self.name,
 8219            'password': self.password,
 8220            'port': self.port,
 8221            'port_override': self.port_override,
 8222            'replica_set': self.replica_set,
 8223            'secret_store_id': self.secret_store_id,
 8224            'tags': self.tags,
 8225            'tls_required': self.tls_required,
 8226            'username': self.username,
 8227        }
 8228
 8229    @classmethod
 8230    def from_dict(cls, d):
 8231        return cls(
 8232            auth_database=d.get('auth_database'),
 8233            bind_interface=d.get('bind_interface'),
 8234            connect_to_replica=d.get('connect_to_replica'),
 8235            egress_filter=d.get('egress_filter'),
 8236            healthy=d.get('healthy'),
 8237            hostname=d.get('hostname'),
 8238            id=d.get('id'),
 8239            name=d.get('name'),
 8240            password=d.get('password'),
 8241            port=d.get('port'),
 8242            port_override=d.get('port_override'),
 8243            replica_set=d.get('replica_set'),
 8244            secret_store_id=d.get('secret_store_id'),
 8245            tags=d.get('tags'),
 8246            tls_required=d.get('tls_required'),
 8247            username=d.get('username'),
 8248        )
 8249
 8250
 8251class MongoReplicaSet:
 8252    '''
 8253
 8254    '''
 8255    __slots__ = [
 8256        'auth_database',
 8257        'bind_interface',
 8258        'connect_to_replica',
 8259        'egress_filter',
 8260        'healthy',
 8261        'hostname',
 8262        'id',
 8263        'name',
 8264        'password',
 8265        'port',
 8266        'port_override',
 8267        'replica_set',
 8268        'secret_store_id',
 8269        'tags',
 8270        'tls_required',
 8271        'username',
 8272    ]
 8273
 8274    def __init__(
 8275        self,
 8276        auth_database=None,
 8277        bind_interface=None,
 8278        connect_to_replica=None,
 8279        egress_filter=None,
 8280        healthy=None,
 8281        hostname=None,
 8282        id=None,
 8283        name=None,
 8284        password=None,
 8285        port=None,
 8286        port_override=None,
 8287        replica_set=None,
 8288        secret_store_id=None,
 8289        tags=None,
 8290        tls_required=None,
 8291        username=None,
 8292    ):
 8293        self.auth_database = auth_database if auth_database is not None else ''
 8294        '''
 8295
 8296        '''
 8297        self.bind_interface = bind_interface if bind_interface is not None else ''
 8298        '''
 8299         Bind interface
 8300        '''
 8301        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 8302        '''
 8303
 8304        '''
 8305        self.egress_filter = egress_filter if egress_filter is not None else ''
 8306        '''
 8307         A filter applied to the routing logic to pin datasource to nodes.
 8308        '''
 8309        self.healthy = healthy if healthy is not None else False
 8310        '''
 8311         True if the datasource is reachable and the credentials are valid.
 8312        '''
 8313        self.hostname = hostname if hostname is not None else ''
 8314        '''
 8315
 8316        '''
 8317        self.id = id if id is not None else ''
 8318        '''
 8319         Unique identifier of the Resource.
 8320        '''
 8321        self.name = name if name is not None else ''
 8322        '''
 8323         Unique human-readable name of the Resource.
 8324        '''
 8325        self.password = password if password is not None else ''
 8326        '''
 8327
 8328        '''
 8329        self.port = port if port is not None else 0
 8330        '''
 8331
 8332        '''
 8333        self.port_override = port_override if port_override is not None else 0
 8334        '''
 8335
 8336        '''
 8337        self.replica_set = replica_set if replica_set is not None else ''
 8338        '''
 8339
 8340        '''
 8341        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8342        '''
 8343         ID of the secret store containing credentials for this resource, if any.
 8344        '''
 8345        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8346        '''
 8347         Tags is a map of key, value pairs.
 8348        '''
 8349        self.tls_required = tls_required if tls_required is not None else False
 8350        '''
 8351
 8352        '''
 8353        self.username = username if username is not None else ''
 8354        '''
 8355
 8356        '''
 8357
 8358    def __repr__(self):
 8359        return '<sdm.MongoReplicaSet ' + \
 8360            'auth_database: ' + repr(self.auth_database) + ' ' +\
 8361            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8362            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 8363            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8364            'healthy: ' + repr(self.healthy) + ' ' +\
 8365            'hostname: ' + repr(self.hostname) + ' ' +\
 8366            'id: ' + repr(self.id) + ' ' +\
 8367            'name: ' + repr(self.name) + ' ' +\
 8368            'password: ' + repr(self.password) + ' ' +\
 8369            'port: ' + repr(self.port) + ' ' +\
 8370            'port_override: ' + repr(self.port_override) + ' ' +\
 8371            'replica_set: ' + repr(self.replica_set) + ' ' +\
 8372            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8373            'tags: ' + repr(self.tags) + ' ' +\
 8374            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8375            'username: ' + repr(self.username) + ' ' +\
 8376            '>'
 8377
 8378    def to_dict(self):
 8379        return {
 8380            'auth_database': self.auth_database,
 8381            'bind_interface': self.bind_interface,
 8382            'connect_to_replica': self.connect_to_replica,
 8383            'egress_filter': self.egress_filter,
 8384            'healthy': self.healthy,
 8385            'hostname': self.hostname,
 8386            'id': self.id,
 8387            'name': self.name,
 8388            'password': self.password,
 8389            'port': self.port,
 8390            'port_override': self.port_override,
 8391            'replica_set': self.replica_set,
 8392            'secret_store_id': self.secret_store_id,
 8393            'tags': self.tags,
 8394            'tls_required': self.tls_required,
 8395            'username': self.username,
 8396        }
 8397
 8398    @classmethod
 8399    def from_dict(cls, d):
 8400        return cls(
 8401            auth_database=d.get('auth_database'),
 8402            bind_interface=d.get('bind_interface'),
 8403            connect_to_replica=d.get('connect_to_replica'),
 8404            egress_filter=d.get('egress_filter'),
 8405            healthy=d.get('healthy'),
 8406            hostname=d.get('hostname'),
 8407            id=d.get('id'),
 8408            name=d.get('name'),
 8409            password=d.get('password'),
 8410            port=d.get('port'),
 8411            port_override=d.get('port_override'),
 8412            replica_set=d.get('replica_set'),
 8413            secret_store_id=d.get('secret_store_id'),
 8414            tags=d.get('tags'),
 8415            tls_required=d.get('tls_required'),
 8416            username=d.get('username'),
 8417        )
 8418
 8419
 8420class MongoShardedCluster:
 8421    '''
 8422
 8423    '''
 8424    __slots__ = [
 8425        'auth_database',
 8426        'bind_interface',
 8427        'egress_filter',
 8428        'healthy',
 8429        'hostname',
 8430        'id',
 8431        'name',
 8432        'password',
 8433        'port_override',
 8434        'secret_store_id',
 8435        'tags',
 8436        'tls_required',
 8437        'username',
 8438    ]
 8439
 8440    def __init__(
 8441        self,
 8442        auth_database=None,
 8443        bind_interface=None,
 8444        egress_filter=None,
 8445        healthy=None,
 8446        hostname=None,
 8447        id=None,
 8448        name=None,
 8449        password=None,
 8450        port_override=None,
 8451        secret_store_id=None,
 8452        tags=None,
 8453        tls_required=None,
 8454        username=None,
 8455    ):
 8456        self.auth_database = auth_database if auth_database is not None else ''
 8457        '''
 8458
 8459        '''
 8460        self.bind_interface = bind_interface if bind_interface is not None else ''
 8461        '''
 8462         Bind interface
 8463        '''
 8464        self.egress_filter = egress_filter if egress_filter is not None else ''
 8465        '''
 8466         A filter applied to the routing logic to pin datasource to nodes.
 8467        '''
 8468        self.healthy = healthy if healthy is not None else False
 8469        '''
 8470         True if the datasource is reachable and the credentials are valid.
 8471        '''
 8472        self.hostname = hostname if hostname is not None else ''
 8473        '''
 8474
 8475        '''
 8476        self.id = id if id is not None else ''
 8477        '''
 8478         Unique identifier of the Resource.
 8479        '''
 8480        self.name = name if name is not None else ''
 8481        '''
 8482         Unique human-readable name of the Resource.
 8483        '''
 8484        self.password = password if password is not None else ''
 8485        '''
 8486
 8487        '''
 8488        self.port_override = port_override if port_override is not None else 0
 8489        '''
 8490
 8491        '''
 8492        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8493        '''
 8494         ID of the secret store containing credentials for this resource, if any.
 8495        '''
 8496        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8497        '''
 8498         Tags is a map of key, value pairs.
 8499        '''
 8500        self.tls_required = tls_required if tls_required is not None else False
 8501        '''
 8502
 8503        '''
 8504        self.username = username if username is not None else ''
 8505        '''
 8506
 8507        '''
 8508
 8509    def __repr__(self):
 8510        return '<sdm.MongoShardedCluster ' + \
 8511            'auth_database: ' + repr(self.auth_database) + ' ' +\
 8512            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8513            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8514            'healthy: ' + repr(self.healthy) + ' ' +\
 8515            'hostname: ' + repr(self.hostname) + ' ' +\
 8516            'id: ' + repr(self.id) + ' ' +\
 8517            'name: ' + repr(self.name) + ' ' +\
 8518            'password: ' + repr(self.password) + ' ' +\
 8519            'port_override: ' + repr(self.port_override) + ' ' +\
 8520            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8521            'tags: ' + repr(self.tags) + ' ' +\
 8522            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8523            'username: ' + repr(self.username) + ' ' +\
 8524            '>'
 8525
 8526    def to_dict(self):
 8527        return {
 8528            'auth_database': self.auth_database,
 8529            'bind_interface': self.bind_interface,
 8530            'egress_filter': self.egress_filter,
 8531            'healthy': self.healthy,
 8532            'hostname': self.hostname,
 8533            'id': self.id,
 8534            'name': self.name,
 8535            'password': self.password,
 8536            'port_override': self.port_override,
 8537            'secret_store_id': self.secret_store_id,
 8538            'tags': self.tags,
 8539            'tls_required': self.tls_required,
 8540            'username': self.username,
 8541        }
 8542
 8543    @classmethod
 8544    def from_dict(cls, d):
 8545        return cls(
 8546            auth_database=d.get('auth_database'),
 8547            bind_interface=d.get('bind_interface'),
 8548            egress_filter=d.get('egress_filter'),
 8549            healthy=d.get('healthy'),
 8550            hostname=d.get('hostname'),
 8551            id=d.get('id'),
 8552            name=d.get('name'),
 8553            password=d.get('password'),
 8554            port_override=d.get('port_override'),
 8555            secret_store_id=d.get('secret_store_id'),
 8556            tags=d.get('tags'),
 8557            tls_required=d.get('tls_required'),
 8558            username=d.get('username'),
 8559        )
 8560
 8561
 8562class Mysql:
 8563    '''
 8564
 8565    '''
 8566    __slots__ = [
 8567        'bind_interface',
 8568        'database',
 8569        'egress_filter',
 8570        'healthy',
 8571        'hostname',
 8572        'id',
 8573        'name',
 8574        'password',
 8575        'port',
 8576        'port_override',
 8577        'secret_store_id',
 8578        'tags',
 8579        'username',
 8580    ]
 8581
 8582    def __init__(
 8583        self,
 8584        bind_interface=None,
 8585        database=None,
 8586        egress_filter=None,
 8587        healthy=None,
 8588        hostname=None,
 8589        id=None,
 8590        name=None,
 8591        password=None,
 8592        port=None,
 8593        port_override=None,
 8594        secret_store_id=None,
 8595        tags=None,
 8596        username=None,
 8597    ):
 8598        self.bind_interface = bind_interface if bind_interface is not None else ''
 8599        '''
 8600         Bind interface
 8601        '''
 8602        self.database = database if database is not None else ''
 8603        '''
 8604
 8605        '''
 8606        self.egress_filter = egress_filter if egress_filter is not None else ''
 8607        '''
 8608         A filter applied to the routing logic to pin datasource to nodes.
 8609        '''
 8610        self.healthy = healthy if healthy is not None else False
 8611        '''
 8612         True if the datasource is reachable and the credentials are valid.
 8613        '''
 8614        self.hostname = hostname if hostname is not None else ''
 8615        '''
 8616
 8617        '''
 8618        self.id = id if id is not None else ''
 8619        '''
 8620         Unique identifier of the Resource.
 8621        '''
 8622        self.name = name if name is not None else ''
 8623        '''
 8624         Unique human-readable name of the Resource.
 8625        '''
 8626        self.password = password if password is not None else ''
 8627        '''
 8628
 8629        '''
 8630        self.port = port if port is not None else 0
 8631        '''
 8632
 8633        '''
 8634        self.port_override = port_override if port_override is not None else 0
 8635        '''
 8636
 8637        '''
 8638        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8639        '''
 8640         ID of the secret store containing credentials for this resource, if any.
 8641        '''
 8642        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8643        '''
 8644         Tags is a map of key, value pairs.
 8645        '''
 8646        self.username = username if username is not None else ''
 8647        '''
 8648
 8649        '''
 8650
 8651    def __repr__(self):
 8652        return '<sdm.Mysql ' + \
 8653            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8654            'database: ' + repr(self.database) + ' ' +\
 8655            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8656            'healthy: ' + repr(self.healthy) + ' ' +\
 8657            'hostname: ' + repr(self.hostname) + ' ' +\
 8658            'id: ' + repr(self.id) + ' ' +\
 8659            'name: ' + repr(self.name) + ' ' +\
 8660            'password: ' + repr(self.password) + ' ' +\
 8661            'port: ' + repr(self.port) + ' ' +\
 8662            'port_override: ' + repr(self.port_override) + ' ' +\
 8663            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8664            'tags: ' + repr(self.tags) + ' ' +\
 8665            'username: ' + repr(self.username) + ' ' +\
 8666            '>'
 8667
 8668    def to_dict(self):
 8669        return {
 8670            'bind_interface': self.bind_interface,
 8671            'database': self.database,
 8672            'egress_filter': self.egress_filter,
 8673            'healthy': self.healthy,
 8674            'hostname': self.hostname,
 8675            'id': self.id,
 8676            'name': self.name,
 8677            'password': self.password,
 8678            'port': self.port,
 8679            'port_override': self.port_override,
 8680            'secret_store_id': self.secret_store_id,
 8681            'tags': self.tags,
 8682            'username': self.username,
 8683        }
 8684
 8685    @classmethod
 8686    def from_dict(cls, d):
 8687        return cls(
 8688            bind_interface=d.get('bind_interface'),
 8689            database=d.get('database'),
 8690            egress_filter=d.get('egress_filter'),
 8691            healthy=d.get('healthy'),
 8692            hostname=d.get('hostname'),
 8693            id=d.get('id'),
 8694            name=d.get('name'),
 8695            password=d.get('password'),
 8696            port=d.get('port'),
 8697            port_override=d.get('port_override'),
 8698            secret_store_id=d.get('secret_store_id'),
 8699            tags=d.get('tags'),
 8700            username=d.get('username'),
 8701        )
 8702
 8703
 8704class Neptune:
 8705    '''
 8706
 8707    '''
 8708    __slots__ = [
 8709        'bind_interface',
 8710        'egress_filter',
 8711        'endpoint',
 8712        'healthy',
 8713        'id',
 8714        'name',
 8715        'port',
 8716        'port_override',
 8717        'secret_store_id',
 8718        'tags',
 8719    ]
 8720
 8721    def __init__(
 8722        self,
 8723        bind_interface=None,
 8724        egress_filter=None,
 8725        endpoint=None,
 8726        healthy=None,
 8727        id=None,
 8728        name=None,
 8729        port=None,
 8730        port_override=None,
 8731        secret_store_id=None,
 8732        tags=None,
 8733    ):
 8734        self.bind_interface = bind_interface if bind_interface is not None else ''
 8735        '''
 8736         Bind interface
 8737        '''
 8738        self.egress_filter = egress_filter if egress_filter is not None else ''
 8739        '''
 8740         A filter applied to the routing logic to pin datasource to nodes.
 8741        '''
 8742        self.endpoint = endpoint if endpoint is not None else ''
 8743        '''
 8744
 8745        '''
 8746        self.healthy = healthy if healthy is not None else False
 8747        '''
 8748         True if the datasource is reachable and the credentials are valid.
 8749        '''
 8750        self.id = id if id is not None else ''
 8751        '''
 8752         Unique identifier of the Resource.
 8753        '''
 8754        self.name = name if name is not None else ''
 8755        '''
 8756         Unique human-readable name of the Resource.
 8757        '''
 8758        self.port = port if port is not None else 0
 8759        '''
 8760
 8761        '''
 8762        self.port_override = port_override if port_override is not None else 0
 8763        '''
 8764
 8765        '''
 8766        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8767        '''
 8768         ID of the secret store containing credentials for this resource, if any.
 8769        '''
 8770        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8771        '''
 8772         Tags is a map of key, value pairs.
 8773        '''
 8774
 8775    def __repr__(self):
 8776        return '<sdm.Neptune ' + \
 8777            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8778            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8779            'endpoint: ' + repr(self.endpoint) + ' ' +\
 8780            'healthy: ' + repr(self.healthy) + ' ' +\
 8781            'id: ' + repr(self.id) + ' ' +\
 8782            'name: ' + repr(self.name) + ' ' +\
 8783            'port: ' + repr(self.port) + ' ' +\
 8784            'port_override: ' + repr(self.port_override) + ' ' +\
 8785            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8786            'tags: ' + repr(self.tags) + ' ' +\
 8787            '>'
 8788
 8789    def to_dict(self):
 8790        return {
 8791            'bind_interface': self.bind_interface,
 8792            'egress_filter': self.egress_filter,
 8793            'endpoint': self.endpoint,
 8794            'healthy': self.healthy,
 8795            'id': self.id,
 8796            'name': self.name,
 8797            'port': self.port,
 8798            'port_override': self.port_override,
 8799            'secret_store_id': self.secret_store_id,
 8800            'tags': self.tags,
 8801        }
 8802
 8803    @classmethod
 8804    def from_dict(cls, d):
 8805        return cls(
 8806            bind_interface=d.get('bind_interface'),
 8807            egress_filter=d.get('egress_filter'),
 8808            endpoint=d.get('endpoint'),
 8809            healthy=d.get('healthy'),
 8810            id=d.get('id'),
 8811            name=d.get('name'),
 8812            port=d.get('port'),
 8813            port_override=d.get('port_override'),
 8814            secret_store_id=d.get('secret_store_id'),
 8815            tags=d.get('tags'),
 8816        )
 8817
 8818
 8819class NeptuneIAM:
 8820    '''
 8821
 8822    '''
 8823    __slots__ = [
 8824        'access_key',
 8825        'bind_interface',
 8826        'egress_filter',
 8827        'endpoint',
 8828        'healthy',
 8829        'id',
 8830        'name',
 8831        'port',
 8832        'port_override',
 8833        'region',
 8834        'role_arn',
 8835        'role_external_id',
 8836        'secret_access_key',
 8837        'secret_store_id',
 8838        'tags',
 8839    ]
 8840
 8841    def __init__(
 8842        self,
 8843        access_key=None,
 8844        bind_interface=None,
 8845        egress_filter=None,
 8846        endpoint=None,
 8847        healthy=None,
 8848        id=None,
 8849        name=None,
 8850        port=None,
 8851        port_override=None,
 8852        region=None,
 8853        role_arn=None,
 8854        role_external_id=None,
 8855        secret_access_key=None,
 8856        secret_store_id=None,
 8857        tags=None,
 8858    ):
 8859        self.access_key = access_key if access_key is not None else ''
 8860        '''
 8861
 8862        '''
 8863        self.bind_interface = bind_interface if bind_interface is not None else ''
 8864        '''
 8865         Bind interface
 8866        '''
 8867        self.egress_filter = egress_filter if egress_filter is not None else ''
 8868        '''
 8869         A filter applied to the routing logic to pin datasource to nodes.
 8870        '''
 8871        self.endpoint = endpoint if endpoint is not None else ''
 8872        '''
 8873
 8874        '''
 8875        self.healthy = healthy if healthy is not None else False
 8876        '''
 8877         True if the datasource is reachable and the credentials are valid.
 8878        '''
 8879        self.id = id if id is not None else ''
 8880        '''
 8881         Unique identifier of the Resource.
 8882        '''
 8883        self.name = name if name is not None else ''
 8884        '''
 8885         Unique human-readable name of the Resource.
 8886        '''
 8887        self.port = port if port is not None else 0
 8888        '''
 8889
 8890        '''
 8891        self.port_override = port_override if port_override is not None else 0
 8892        '''
 8893
 8894        '''
 8895        self.region = region if region is not None else ''
 8896        '''
 8897
 8898        '''
 8899        self.role_arn = role_arn if role_arn is not None else ''
 8900        '''
 8901
 8902        '''
 8903        self.role_external_id = role_external_id if role_external_id is not None else ''
 8904        '''
 8905
 8906        '''
 8907        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 8908        '''
 8909
 8910        '''
 8911        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8912        '''
 8913         ID of the secret store containing credentials for this resource, if any.
 8914        '''
 8915        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8916        '''
 8917         Tags is a map of key, value pairs.
 8918        '''
 8919
 8920    def __repr__(self):
 8921        return '<sdm.NeptuneIAM ' + \
 8922            'access_key: ' + repr(self.access_key) + ' ' +\
 8923            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8924            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8925            'endpoint: ' + repr(self.endpoint) + ' ' +\
 8926            'healthy: ' + repr(self.healthy) + ' ' +\
 8927            'id: ' + repr(self.id) + ' ' +\
 8928            'name: ' + repr(self.name) + ' ' +\
 8929            'port: ' + repr(self.port) + ' ' +\
 8930            'port_override: ' + repr(self.port_override) + ' ' +\
 8931            'region: ' + repr(self.region) + ' ' +\
 8932            'role_arn: ' + repr(self.role_arn) + ' ' +\
 8933            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 8934            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 8935            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8936            'tags: ' + repr(self.tags) + ' ' +\
 8937            '>'
 8938
 8939    def to_dict(self):
 8940        return {
 8941            'access_key': self.access_key,
 8942            'bind_interface': self.bind_interface,
 8943            'egress_filter': self.egress_filter,
 8944            'endpoint': self.endpoint,
 8945            'healthy': self.healthy,
 8946            'id': self.id,
 8947            'name': self.name,
 8948            'port': self.port,
 8949            'port_override': self.port_override,
 8950            'region': self.region,
 8951            'role_arn': self.role_arn,
 8952            'role_external_id': self.role_external_id,
 8953            'secret_access_key': self.secret_access_key,
 8954            'secret_store_id': self.secret_store_id,
 8955            'tags': self.tags,
 8956        }
 8957
 8958    @classmethod
 8959    def from_dict(cls, d):
 8960        return cls(
 8961            access_key=d.get('access_key'),
 8962            bind_interface=d.get('bind_interface'),
 8963            egress_filter=d.get('egress_filter'),
 8964            endpoint=d.get('endpoint'),
 8965            healthy=d.get('healthy'),
 8966            id=d.get('id'),
 8967            name=d.get('name'),
 8968            port=d.get('port'),
 8969            port_override=d.get('port_override'),
 8970            region=d.get('region'),
 8971            role_arn=d.get('role_arn'),
 8972            role_external_id=d.get('role_external_id'),
 8973            secret_access_key=d.get('secret_access_key'),
 8974            secret_store_id=d.get('secret_store_id'),
 8975            tags=d.get('tags'),
 8976        )
 8977
 8978
 8979class NodeCreateResponse:
 8980    '''
 8981     NodeCreateResponse reports how the Nodes were created in the system.
 8982    '''
 8983    __slots__ = [
 8984        'meta',
 8985        'node',
 8986        'rate_limit',
 8987        'token',
 8988    ]
 8989
 8990    def __init__(
 8991        self,
 8992        meta=None,
 8993        node=None,
 8994        rate_limit=None,
 8995        token=None,
 8996    ):
 8997        self.meta = meta if meta is not None else None
 8998        '''
 8999         Reserved for future use.
 9000        '''
 9001        self.node = node if node is not None else None
 9002        '''
 9003         The created Node.
 9004        '''
 9005        self.rate_limit = rate_limit if rate_limit is not None else None
 9006        '''
 9007         Rate limit information.
 9008        '''
 9009        self.token = token if token is not None else ''
 9010        '''
 9011         The auth token generated for the Node. The Node will use this token to
 9012         authenticate with the strongDM API.
 9013        '''
 9014
 9015    def __repr__(self):
 9016        return '<sdm.NodeCreateResponse ' + \
 9017            'meta: ' + repr(self.meta) + ' ' +\
 9018            'node: ' + repr(self.node) + ' ' +\
 9019            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9020            'token: ' + repr(self.token) + ' ' +\
 9021            '>'
 9022
 9023    def to_dict(self):
 9024        return {
 9025            'meta': self.meta,
 9026            'node': self.node,
 9027            'rate_limit': self.rate_limit,
 9028            'token': self.token,
 9029        }
 9030
 9031    @classmethod
 9032    def from_dict(cls, d):
 9033        return cls(
 9034            meta=d.get('meta'),
 9035            node=d.get('node'),
 9036            rate_limit=d.get('rate_limit'),
 9037            token=d.get('token'),
 9038        )
 9039
 9040
 9041class NodeDeleteResponse:
 9042    '''
 9043     NodeDeleteResponse returns information about a Node that was deleted.
 9044    '''
 9045    __slots__ = [
 9046        'meta',
 9047        'rate_limit',
 9048    ]
 9049
 9050    def __init__(
 9051        self,
 9052        meta=None,
 9053        rate_limit=None,
 9054    ):
 9055        self.meta = meta if meta is not None else None
 9056        '''
 9057         Reserved for future use.
 9058        '''
 9059        self.rate_limit = rate_limit if rate_limit is not None else None
 9060        '''
 9061         Rate limit information.
 9062        '''
 9063
 9064    def __repr__(self):
 9065        return '<sdm.NodeDeleteResponse ' + \
 9066            'meta: ' + repr(self.meta) + ' ' +\
 9067            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9068            '>'
 9069
 9070    def to_dict(self):
 9071        return {
 9072            'meta': self.meta,
 9073            'rate_limit': self.rate_limit,
 9074        }
 9075
 9076    @classmethod
 9077    def from_dict(cls, d):
 9078        return cls(
 9079            meta=d.get('meta'),
 9080            rate_limit=d.get('rate_limit'),
 9081        )
 9082
 9083
 9084class NodeGetResponse:
 9085    '''
 9086     NodeGetResponse returns a requested Node.
 9087    '''
 9088    __slots__ = [
 9089        'meta',
 9090        'node',
 9091        'rate_limit',
 9092    ]
 9093
 9094    def __init__(
 9095        self,
 9096        meta=None,
 9097        node=None,
 9098        rate_limit=None,
 9099    ):
 9100        self.meta = meta if meta is not None else None
 9101        '''
 9102         Reserved for future use.
 9103        '''
 9104        self.node = node if node is not None else None
 9105        '''
 9106         The requested Node.
 9107        '''
 9108        self.rate_limit = rate_limit if rate_limit is not None else None
 9109        '''
 9110         Rate limit information.
 9111        '''
 9112
 9113    def __repr__(self):
 9114        return '<sdm.NodeGetResponse ' + \
 9115            'meta: ' + repr(self.meta) + ' ' +\
 9116            'node: ' + repr(self.node) + ' ' +\
 9117            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9118            '>'
 9119
 9120    def to_dict(self):
 9121        return {
 9122            'meta': self.meta,
 9123            'node': self.node,
 9124            'rate_limit': self.rate_limit,
 9125        }
 9126
 9127    @classmethod
 9128    def from_dict(cls, d):
 9129        return cls(
 9130            meta=d.get('meta'),
 9131            node=d.get('node'),
 9132            rate_limit=d.get('rate_limit'),
 9133        )
 9134
 9135
 9136class NodeUpdateResponse:
 9137    '''
 9138     NodeUpdateResponse returns the fields of a Node after it has been updated by
 9139     a NodeUpdateRequest.
 9140    '''
 9141    __slots__ = [
 9142        'meta',
 9143        'node',
 9144        'rate_limit',
 9145    ]
 9146
 9147    def __init__(
 9148        self,
 9149        meta=None,
 9150        node=None,
 9151        rate_limit=None,
 9152    ):
 9153        self.meta = meta if meta is not None else None
 9154        '''
 9155         Reserved for future use.
 9156        '''
 9157        self.node = node if node is not None else None
 9158        '''
 9159         The updated Node.
 9160        '''
 9161        self.rate_limit = rate_limit if rate_limit is not None else None
 9162        '''
 9163         Rate limit information.
 9164        '''
 9165
 9166    def __repr__(self):
 9167        return '<sdm.NodeUpdateResponse ' + \
 9168            'meta: ' + repr(self.meta) + ' ' +\
 9169            'node: ' + repr(self.node) + ' ' +\
 9170            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9171            '>'
 9172
 9173    def to_dict(self):
 9174        return {
 9175            'meta': self.meta,
 9176            'node': self.node,
 9177            'rate_limit': self.rate_limit,
 9178        }
 9179
 9180    @classmethod
 9181    def from_dict(cls, d):
 9182        return cls(
 9183            meta=d.get('meta'),
 9184            node=d.get('node'),
 9185            rate_limit=d.get('rate_limit'),
 9186        )
 9187
 9188
 9189class Oracle:
 9190    '''
 9191
 9192    '''
 9193    __slots__ = [
 9194        'bind_interface',
 9195        'database',
 9196        'egress_filter',
 9197        'healthy',
 9198        'hostname',
 9199        'id',
 9200        'name',
 9201        'password',
 9202        'port',
 9203        'port_override',
 9204        'secret_store_id',
 9205        'tags',
 9206        'tls_required',
 9207        'username',
 9208    ]
 9209
 9210    def __init__(
 9211        self,
 9212        bind_interface=None,
 9213        database=None,
 9214        egress_filter=None,
 9215        healthy=None,
 9216        hostname=None,
 9217        id=None,
 9218        name=None,
 9219        password=None,
 9220        port=None,
 9221        port_override=None,
 9222        secret_store_id=None,
 9223        tags=None,
 9224        tls_required=None,
 9225        username=None,
 9226    ):
 9227        self.bind_interface = bind_interface if bind_interface is not None else ''
 9228        '''
 9229         Bind interface
 9230        '''
 9231        self.database = database if database is not None else ''
 9232        '''
 9233
 9234        '''
 9235        self.egress_filter = egress_filter if egress_filter is not None else ''
 9236        '''
 9237         A filter applied to the routing logic to pin datasource to nodes.
 9238        '''
 9239        self.healthy = healthy if healthy is not None else False
 9240        '''
 9241         True if the datasource is reachable and the credentials are valid.
 9242        '''
 9243        self.hostname = hostname if hostname is not None else ''
 9244        '''
 9245
 9246        '''
 9247        self.id = id if id is not None else ''
 9248        '''
 9249         Unique identifier of the Resource.
 9250        '''
 9251        self.name = name if name is not None else ''
 9252        '''
 9253         Unique human-readable name of the Resource.
 9254        '''
 9255        self.password = password if password is not None else ''
 9256        '''
 9257
 9258        '''
 9259        self.port = port if port is not None else 0
 9260        '''
 9261
 9262        '''
 9263        self.port_override = port_override if port_override is not None else 0
 9264        '''
 9265
 9266        '''
 9267        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9268        '''
 9269         ID of the secret store containing credentials for this resource, if any.
 9270        '''
 9271        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9272        '''
 9273         Tags is a map of key, value pairs.
 9274        '''
 9275        self.tls_required = tls_required if tls_required is not None else False
 9276        '''
 9277
 9278        '''
 9279        self.username = username if username is not None else ''
 9280        '''
 9281
 9282        '''
 9283
 9284    def __repr__(self):
 9285        return '<sdm.Oracle ' + \
 9286            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9287            'database: ' + repr(self.database) + ' ' +\
 9288            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9289            'healthy: ' + repr(self.healthy) + ' ' +\
 9290            'hostname: ' + repr(self.hostname) + ' ' +\
 9291            'id: ' + repr(self.id) + ' ' +\
 9292            'name: ' + repr(self.name) + ' ' +\
 9293            'password: ' + repr(self.password) + ' ' +\
 9294            'port: ' + repr(self.port) + ' ' +\
 9295            'port_override: ' + repr(self.port_override) + ' ' +\
 9296            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9297            'tags: ' + repr(self.tags) + ' ' +\
 9298            'tls_required: ' + repr(self.tls_required) + ' ' +\
 9299            'username: ' + repr(self.username) + ' ' +\
 9300            '>'
 9301
 9302    def to_dict(self):
 9303        return {
 9304            'bind_interface': self.bind_interface,
 9305            'database': self.database,
 9306            'egress_filter': self.egress_filter,
 9307            'healthy': self.healthy,
 9308            'hostname': self.hostname,
 9309            'id': self.id,
 9310            'name': self.name,
 9311            'password': self.password,
 9312            'port': self.port,
 9313            'port_override': self.port_override,
 9314            'secret_store_id': self.secret_store_id,
 9315            'tags': self.tags,
 9316            'tls_required': self.tls_required,
 9317            'username': self.username,
 9318        }
 9319
 9320    @classmethod
 9321    def from_dict(cls, d):
 9322        return cls(
 9323            bind_interface=d.get('bind_interface'),
 9324            database=d.get('database'),
 9325            egress_filter=d.get('egress_filter'),
 9326            healthy=d.get('healthy'),
 9327            hostname=d.get('hostname'),
 9328            id=d.get('id'),
 9329            name=d.get('name'),
 9330            password=d.get('password'),
 9331            port=d.get('port'),
 9332            port_override=d.get('port_override'),
 9333            secret_store_id=d.get('secret_store_id'),
 9334            tags=d.get('tags'),
 9335            tls_required=d.get('tls_required'),
 9336            username=d.get('username'),
 9337        )
 9338
 9339
 9340class Postgres:
 9341    '''
 9342
 9343    '''
 9344    __slots__ = [
 9345        'bind_interface',
 9346        'database',
 9347        'egress_filter',
 9348        'healthy',
 9349        'hostname',
 9350        'id',
 9351        'name',
 9352        'override_database',
 9353        'password',
 9354        'port',
 9355        'port_override',
 9356        'secret_store_id',
 9357        'tags',
 9358        'username',
 9359    ]
 9360
 9361    def __init__(
 9362        self,
 9363        bind_interface=None,
 9364        database=None,
 9365        egress_filter=None,
 9366        healthy=None,
 9367        hostname=None,
 9368        id=None,
 9369        name=None,
 9370        override_database=None,
 9371        password=None,
 9372        port=None,
 9373        port_override=None,
 9374        secret_store_id=None,
 9375        tags=None,
 9376        username=None,
 9377    ):
 9378        self.bind_interface = bind_interface if bind_interface is not None else ''
 9379        '''
 9380         Bind interface
 9381        '''
 9382        self.database = database if database is not None else ''
 9383        '''
 9384
 9385        '''
 9386        self.egress_filter = egress_filter if egress_filter is not None else ''
 9387        '''
 9388         A filter applied to the routing logic to pin datasource to nodes.
 9389        '''
 9390        self.healthy = healthy if healthy is not None else False
 9391        '''
 9392         True if the datasource is reachable and the credentials are valid.
 9393        '''
 9394        self.hostname = hostname if hostname is not None else ''
 9395        '''
 9396
 9397        '''
 9398        self.id = id if id is not None else ''
 9399        '''
 9400         Unique identifier of the Resource.
 9401        '''
 9402        self.name = name if name is not None else ''
 9403        '''
 9404         Unique human-readable name of the Resource.
 9405        '''
 9406        self.override_database = override_database if override_database is not None else False
 9407        '''
 9408
 9409        '''
 9410        self.password = password if password is not None else ''
 9411        '''
 9412
 9413        '''
 9414        self.port = port if port is not None else 0
 9415        '''
 9416
 9417        '''
 9418        self.port_override = port_override if port_override is not None else 0
 9419        '''
 9420
 9421        '''
 9422        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9423        '''
 9424         ID of the secret store containing credentials for this resource, if any.
 9425        '''
 9426        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9427        '''
 9428         Tags is a map of key, value pairs.
 9429        '''
 9430        self.username = username if username is not None else ''
 9431        '''
 9432
 9433        '''
 9434
 9435    def __repr__(self):
 9436        return '<sdm.Postgres ' + \
 9437            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9438            'database: ' + repr(self.database) + ' ' +\
 9439            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9440            'healthy: ' + repr(self.healthy) + ' ' +\
 9441            'hostname: ' + repr(self.hostname) + ' ' +\
 9442            'id: ' + repr(self.id) + ' ' +\
 9443            'name: ' + repr(self.name) + ' ' +\
 9444            'override_database: ' + repr(self.override_database) + ' ' +\
 9445            'password: ' + repr(self.password) + ' ' +\
 9446            'port: ' + repr(self.port) + ' ' +\
 9447            'port_override: ' + repr(self.port_override) + ' ' +\
 9448            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9449            'tags: ' + repr(self.tags) + ' ' +\
 9450            'username: ' + repr(self.username) + ' ' +\
 9451            '>'
 9452
 9453    def to_dict(self):
 9454        return {
 9455            'bind_interface': self.bind_interface,
 9456            'database': self.database,
 9457            'egress_filter': self.egress_filter,
 9458            'healthy': self.healthy,
 9459            'hostname': self.hostname,
 9460            'id': self.id,
 9461            'name': self.name,
 9462            'override_database': self.override_database,
 9463            'password': self.password,
 9464            'port': self.port,
 9465            'port_override': self.port_override,
 9466            'secret_store_id': self.secret_store_id,
 9467            'tags': self.tags,
 9468            'username': self.username,
 9469        }
 9470
 9471    @classmethod
 9472    def from_dict(cls, d):
 9473        return cls(
 9474            bind_interface=d.get('bind_interface'),
 9475            database=d.get('database'),
 9476            egress_filter=d.get('egress_filter'),
 9477            healthy=d.get('healthy'),
 9478            hostname=d.get('hostname'),
 9479            id=d.get('id'),
 9480            name=d.get('name'),
 9481            override_database=d.get('override_database'),
 9482            password=d.get('password'),
 9483            port=d.get('port'),
 9484            port_override=d.get('port_override'),
 9485            secret_store_id=d.get('secret_store_id'),
 9486            tags=d.get('tags'),
 9487            username=d.get('username'),
 9488        )
 9489
 9490
 9491class Presto:
 9492    '''
 9493
 9494    '''
 9495    __slots__ = [
 9496        'bind_interface',
 9497        'database',
 9498        'egress_filter',
 9499        'healthy',
 9500        'hostname',
 9501        'id',
 9502        'name',
 9503        'password',
 9504        'port',
 9505        'port_override',
 9506        'secret_store_id',
 9507        'tags',
 9508        'tls_required',
 9509        'username',
 9510    ]
 9511
 9512    def __init__(
 9513        self,
 9514        bind_interface=None,
 9515        database=None,
 9516        egress_filter=None,
 9517        healthy=None,
 9518        hostname=None,
 9519        id=None,
 9520        name=None,
 9521        password=None,
 9522        port=None,
 9523        port_override=None,
 9524        secret_store_id=None,
 9525        tags=None,
 9526        tls_required=None,
 9527        username=None,
 9528    ):
 9529        self.bind_interface = bind_interface if bind_interface is not None else ''
 9530        '''
 9531         Bind interface
 9532        '''
 9533        self.database = database if database is not None else ''
 9534        '''
 9535
 9536        '''
 9537        self.egress_filter = egress_filter if egress_filter is not None else ''
 9538        '''
 9539         A filter applied to the routing logic to pin datasource to nodes.
 9540        '''
 9541        self.healthy = healthy if healthy is not None else False
 9542        '''
 9543         True if the datasource is reachable and the credentials are valid.
 9544        '''
 9545        self.hostname = hostname if hostname is not None else ''
 9546        '''
 9547
 9548        '''
 9549        self.id = id if id is not None else ''
 9550        '''
 9551         Unique identifier of the Resource.
 9552        '''
 9553        self.name = name if name is not None else ''
 9554        '''
 9555         Unique human-readable name of the Resource.
 9556        '''
 9557        self.password = password if password is not None else ''
 9558        '''
 9559
 9560        '''
 9561        self.port = port if port is not None else 0
 9562        '''
 9563
 9564        '''
 9565        self.port_override = port_override if port_override is not None else 0
 9566        '''
 9567
 9568        '''
 9569        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9570        '''
 9571         ID of the secret store containing credentials for this resource, if any.
 9572        '''
 9573        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9574        '''
 9575         Tags is a map of key, value pairs.
 9576        '''
 9577        self.tls_required = tls_required if tls_required is not None else False
 9578        '''
 9579
 9580        '''
 9581        self.username = username if username is not None else ''
 9582        '''
 9583
 9584        '''
 9585
 9586    def __repr__(self):
 9587        return '<sdm.Presto ' + \
 9588            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9589            'database: ' + repr(self.database) + ' ' +\
 9590            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9591            'healthy: ' + repr(self.healthy) + ' ' +\
 9592            'hostname: ' + repr(self.hostname) + ' ' +\
 9593            'id: ' + repr(self.id) + ' ' +\
 9594            'name: ' + repr(self.name) + ' ' +\
 9595            'password: ' + repr(self.password) + ' ' +\
 9596            'port: ' + repr(self.port) + ' ' +\
 9597            'port_override: ' + repr(self.port_override) + ' ' +\
 9598            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9599            'tags: ' + repr(self.tags) + ' ' +\
 9600            'tls_required: ' + repr(self.tls_required) + ' ' +\
 9601            'username: ' + repr(self.username) + ' ' +\
 9602            '>'
 9603
 9604    def to_dict(self):
 9605        return {
 9606            'bind_interface': self.bind_interface,
 9607            'database': self.database,
 9608            'egress_filter': self.egress_filter,
 9609            'healthy': self.healthy,
 9610            'hostname': self.hostname,
 9611            'id': self.id,
 9612            'name': self.name,
 9613            'password': self.password,
 9614            'port': self.port,
 9615            'port_override': self.port_override,
 9616            'secret_store_id': self.secret_store_id,
 9617            'tags': self.tags,
 9618            'tls_required': self.tls_required,
 9619            'username': self.username,
 9620        }
 9621
 9622    @classmethod
 9623    def from_dict(cls, d):
 9624        return cls(
 9625            bind_interface=d.get('bind_interface'),
 9626            database=d.get('database'),
 9627            egress_filter=d.get('egress_filter'),
 9628            healthy=d.get('healthy'),
 9629            hostname=d.get('hostname'),
 9630            id=d.get('id'),
 9631            name=d.get('name'),
 9632            password=d.get('password'),
 9633            port=d.get('port'),
 9634            port_override=d.get('port_override'),
 9635            secret_store_id=d.get('secret_store_id'),
 9636            tags=d.get('tags'),
 9637            tls_required=d.get('tls_required'),
 9638            username=d.get('username'),
 9639        )
 9640
 9641
 9642class RDP:
 9643    '''
 9644
 9645    '''
 9646    __slots__ = [
 9647        'bind_interface',
 9648        'downgrade_nla_connections',
 9649        'egress_filter',
 9650        'healthy',
 9651        'hostname',
 9652        'id',
 9653        'name',
 9654        'password',
 9655        'port',
 9656        'port_override',
 9657        'secret_store_id',
 9658        'tags',
 9659        'username',
 9660    ]
 9661
 9662    def __init__(
 9663        self,
 9664        bind_interface=None,
 9665        downgrade_nla_connections=None,
 9666        egress_filter=None,
 9667        healthy=None,
 9668        hostname=None,
 9669        id=None,
 9670        name=None,
 9671        password=None,
 9672        port=None,
 9673        port_override=None,
 9674        secret_store_id=None,
 9675        tags=None,
 9676        username=None,
 9677    ):
 9678        self.bind_interface = bind_interface if bind_interface is not None else ''
 9679        '''
 9680         Bind interface
 9681        '''
 9682        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
 9683        '''
 9684
 9685        '''
 9686        self.egress_filter = egress_filter if egress_filter is not None else ''
 9687        '''
 9688         A filter applied to the routing logic to pin datasource to nodes.
 9689        '''
 9690        self.healthy = healthy if healthy is not None else False
 9691        '''
 9692         True if the datasource is reachable and the credentials are valid.
 9693        '''
 9694        self.hostname = hostname if hostname is not None else ''
 9695        '''
 9696
 9697        '''
 9698        self.id = id if id is not None else ''
 9699        '''
 9700         Unique identifier of the Resource.
 9701        '''
 9702        self.name = name if name is not None else ''
 9703        '''
 9704         Unique human-readable name of the Resource.
 9705        '''
 9706        self.password = password if password is not None else ''
 9707        '''
 9708
 9709        '''
 9710        self.port = port if port is not None else 0
 9711        '''
 9712
 9713        '''
 9714        self.port_override = port_override if port_override is not None else 0
 9715        '''
 9716
 9717        '''
 9718        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9719        '''
 9720         ID of the secret store containing credentials for this resource, if any.
 9721        '''
 9722        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9723        '''
 9724         Tags is a map of key, value pairs.
 9725        '''
 9726        self.username = username if username is not None else ''
 9727        '''
 9728
 9729        '''
 9730
 9731    def __repr__(self):
 9732        return '<sdm.RDP ' + \
 9733            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9734            'downgrade_nla_connections: ' + repr(self.downgrade_nla_connections) + ' ' +\
 9735            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9736            'healthy: ' + repr(self.healthy) + ' ' +\
 9737            'hostname: ' + repr(self.hostname) + ' ' +\
 9738            'id: ' + repr(self.id) + ' ' +\
 9739            'name: ' + repr(self.name) + ' ' +\
 9740            'password: ' + repr(self.password) + ' ' +\
 9741            'port: ' + repr(self.port) + ' ' +\
 9742            'port_override: ' + repr(self.port_override) + ' ' +\
 9743            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9744            'tags: ' + repr(self.tags) + ' ' +\
 9745            'username: ' + repr(self.username) + ' ' +\
 9746            '>'
 9747
 9748    def to_dict(self):
 9749        return {
 9750            'bind_interface': self.bind_interface,
 9751            'downgrade_nla_connections': self.downgrade_nla_connections,
 9752            'egress_filter': self.egress_filter,
 9753            'healthy': self.healthy,
 9754            'hostname': self.hostname,
 9755            'id': self.id,
 9756            'name': self.name,
 9757            'password': self.password,
 9758            'port': self.port,
 9759            'port_override': self.port_override,
 9760            'secret_store_id': self.secret_store_id,
 9761            'tags': self.tags,
 9762            'username': self.username,
 9763        }
 9764
 9765    @classmethod
 9766    def from_dict(cls, d):
 9767        return cls(
 9768            bind_interface=d.get('bind_interface'),
 9769            downgrade_nla_connections=d.get('downgrade_nla_connections'),
 9770            egress_filter=d.get('egress_filter'),
 9771            healthy=d.get('healthy'),
 9772            hostname=d.get('hostname'),
 9773            id=d.get('id'),
 9774            name=d.get('name'),
 9775            password=d.get('password'),
 9776            port=d.get('port'),
 9777            port_override=d.get('port_override'),
 9778            secret_store_id=d.get('secret_store_id'),
 9779            tags=d.get('tags'),
 9780            username=d.get('username'),
 9781        )
 9782
 9783
 9784class RabbitMQAMQP091:
 9785    '''
 9786
 9787    '''
 9788    __slots__ = [
 9789        'bind_interface',
 9790        'egress_filter',
 9791        'healthy',
 9792        'hostname',
 9793        'id',
 9794        'name',
 9795        'password',
 9796        'port',
 9797        'port_override',
 9798        'secret_store_id',
 9799        'tags',
 9800        'tls_required',
 9801        'username',
 9802    ]
 9803
 9804    def __init__(
 9805        self,
 9806        bind_interface=None,
 9807        egress_filter=None,
 9808        healthy=None,
 9809        hostname=None,
 9810        id=None,
 9811        name=None,
 9812        password=None,
 9813        port=None,
 9814        port_override=None,
 9815        secret_store_id=None,
 9816        tags=None,
 9817        tls_required=None,
 9818        username=None,
 9819    ):
 9820        self.bind_interface = bind_interface if bind_interface is not None else ''
 9821        '''
 9822         Bind interface
 9823        '''
 9824        self.egress_filter = egress_filter if egress_filter is not None else ''
 9825        '''
 9826         A filter applied to the routing logic to pin datasource to nodes.
 9827        '''
 9828        self.healthy = healthy if healthy is not None else False
 9829        '''
 9830         True if the datasource is reachable and the credentials are valid.
 9831        '''
 9832        self.hostname = hostname if hostname is not None else ''
 9833        '''
 9834
 9835        '''
 9836        self.id = id if id is not None else ''
 9837        '''
 9838         Unique identifier of the Resource.
 9839        '''
 9840        self.name = name if name is not None else ''
 9841        '''
 9842         Unique human-readable name of the Resource.
 9843        '''
 9844        self.password = password if password is not None else ''
 9845        '''
 9846
 9847        '''
 9848        self.port = port if port is not None else 0
 9849        '''
 9850
 9851        '''
 9852        self.port_override = port_override if port_override is not None else 0
 9853        '''
 9854
 9855        '''
 9856        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9857        '''
 9858         ID of the secret store containing credentials for this resource, if any.
 9859        '''
 9860        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9861        '''
 9862         Tags is a map of key, value pairs.
 9863        '''
 9864        self.tls_required = tls_required if tls_required is not None else False
 9865        '''
 9866
 9867        '''
 9868        self.username = username if username is not None else ''
 9869        '''
 9870
 9871        '''
 9872
 9873    def __repr__(self):
 9874        return '<sdm.RabbitMQAMQP091 ' + \
 9875            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9876            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9877            'healthy: ' + repr(self.healthy) + ' ' +\
 9878            'hostname: ' + repr(self.hostname) + ' ' +\
 9879            'id: ' + repr(self.id) + ' ' +\
 9880            'name: ' + repr(self.name) + ' ' +\
 9881            'password: ' + repr(self.password) + ' ' +\
 9882            'port: ' + repr(self.port) + ' ' +\
 9883            'port_override: ' + repr(self.port_override) + ' ' +\
 9884            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9885            'tags: ' + repr(self.tags) + ' ' +\
 9886            'tls_required: ' + repr(self.tls_required) + ' ' +\
 9887            'username: ' + repr(self.username) + ' ' +\
 9888            '>'
 9889
 9890    def to_dict(self):
 9891        return {
 9892            'bind_interface': self.bind_interface,
 9893            'egress_filter': self.egress_filter,
 9894            'healthy': self.healthy,
 9895            'hostname': self.hostname,
 9896            'id': self.id,
 9897            'name': self.name,
 9898            'password': self.password,
 9899            'port': self.port,
 9900            'port_override': self.port_override,
 9901            'secret_store_id': self.secret_store_id,
 9902            'tags': self.tags,
 9903            'tls_required': self.tls_required,
 9904            'username': self.username,
 9905        }
 9906
 9907    @classmethod
 9908    def from_dict(cls, d):
 9909        return cls(
 9910            bind_interface=d.get('bind_interface'),
 9911            egress_filter=d.get('egress_filter'),
 9912            healthy=d.get('healthy'),
 9913            hostname=d.get('hostname'),
 9914            id=d.get('id'),
 9915            name=d.get('name'),
 9916            password=d.get('password'),
 9917            port=d.get('port'),
 9918            port_override=d.get('port_override'),
 9919            secret_store_id=d.get('secret_store_id'),
 9920            tags=d.get('tags'),
 9921            tls_required=d.get('tls_required'),
 9922            username=d.get('username'),
 9923        )
 9924
 9925
 9926class RateLimitMetadata:
 9927    '''
 9928     RateLimitMetadata contains information about remaining requests avaialable
 9929     to the user over some timeframe.
 9930    '''
 9931    __slots__ = [
 9932        'bucket',
 9933        'limit',
 9934        'remaining',
 9935        'reset_at',
 9936    ]
 9937
 9938    def __init__(
 9939        self,
 9940        bucket=None,
 9941        limit=None,
 9942        remaining=None,
 9943        reset_at=None,
 9944    ):
 9945        self.bucket = bucket if bucket is not None else ''
 9946        '''
 9947         The bucket this user/token is associated with, which may be shared between
 9948         multiple users/tokens.
 9949        '''
 9950        self.limit = limit if limit is not None else 0
 9951        '''
 9952         How many total requests the user/token is authorized to make before being
 9953         rate limited.
 9954        '''
 9955        self.remaining = remaining if remaining is not None else 0
 9956        '''
 9957         How many remaining requests out of the limit are still avaialable.
 9958        '''
 9959        self.reset_at = reset_at if reset_at is not None else None
 9960        '''
 9961         The time when remaining will be reset to limit.
 9962        '''
 9963
 9964    def __repr__(self):
 9965        return '<sdm.RateLimitMetadata ' + \
 9966            'bucket: ' + repr(self.bucket) + ' ' +\
 9967            'limit: ' + repr(self.limit) + ' ' +\
 9968            'remaining: ' + repr(self.remaining) + ' ' +\
 9969            'reset_at: ' + repr(self.reset_at) + ' ' +\
 9970            '>'
 9971
 9972    def to_dict(self):
 9973        return {
 9974            'bucket': self.bucket,
 9975            'limit': self.limit,
 9976            'remaining': self.remaining,
 9977            'reset_at': self.reset_at,
 9978        }
 9979
 9980    @classmethod
 9981    def from_dict(cls, d):
 9982        return cls(
 9983            bucket=d.get('bucket'),
 9984            limit=d.get('limit'),
 9985            remaining=d.get('remaining'),
 9986            reset_at=d.get('reset_at'),
 9987        )
 9988
 9989
 9990class RawTCP:
 9991    '''
 9992
 9993    '''
 9994    __slots__ = [
 9995        'bind_interface',
 9996        'egress_filter',
 9997        'healthy',
 9998        'hostname',
 9999        'id',
10000        'name',
10001        'port',
10002        'port_override',
10003        'secret_store_id',
10004        'tags',
10005    ]
10006
10007    def __init__(
10008        self,
10009        bind_interface=None,
10010        egress_filter=None,
10011        healthy=None,
10012        hostname=None,
10013        id=None,
10014        name=None,
10015        port=None,
10016        port_override=None,
10017        secret_store_id=None,
10018        tags=None,
10019    ):
10020        self.bind_interface = bind_interface if bind_interface is not None else ''
10021        '''
10022         Bind interface
10023        '''
10024        self.egress_filter = egress_filter if egress_filter is not None else ''
10025        '''
10026         A filter applied to the routing logic to pin datasource to nodes.
10027        '''
10028        self.healthy = healthy if healthy is not None else False
10029        '''
10030         True if the datasource is reachable and the credentials are valid.
10031        '''
10032        self.hostname = hostname if hostname is not None else ''
10033        '''
10034
10035        '''
10036        self.id = id if id is not None else ''
10037        '''
10038         Unique identifier of the Resource.
10039        '''
10040        self.name = name if name is not None else ''
10041        '''
10042         Unique human-readable name of the Resource.
10043        '''
10044        self.port = port if port is not None else 0
10045        '''
10046
10047        '''
10048        self.port_override = port_override if port_override is not None else 0
10049        '''
10050
10051        '''
10052        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10053        '''
10054         ID of the secret store containing credentials for this resource, if any.
10055        '''
10056        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10057        '''
10058         Tags is a map of key, value pairs.
10059        '''
10060
10061    def __repr__(self):
10062        return '<sdm.RawTCP ' + \
10063            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10064            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10065            'healthy: ' + repr(self.healthy) + ' ' +\
10066            'hostname: ' + repr(self.hostname) + ' ' +\
10067            'id: ' + repr(self.id) + ' ' +\
10068            'name: ' + repr(self.name) + ' ' +\
10069            'port: ' + repr(self.port) + ' ' +\
10070            'port_override: ' + repr(self.port_override) + ' ' +\
10071            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10072            'tags: ' + repr(self.tags) + ' ' +\
10073            '>'
10074
10075    def to_dict(self):
10076        return {
10077            'bind_interface': self.bind_interface,
10078            'egress_filter': self.egress_filter,
10079            'healthy': self.healthy,
10080            'hostname': self.hostname,
10081            'id': self.id,
10082            'name': self.name,
10083            'port': self.port,
10084            'port_override': self.port_override,
10085            'secret_store_id': self.secret_store_id,
10086            'tags': self.tags,
10087        }
10088
10089    @classmethod
10090    def from_dict(cls, d):
10091        return cls(
10092            bind_interface=d.get('bind_interface'),
10093            egress_filter=d.get('egress_filter'),
10094            healthy=d.get('healthy'),
10095            hostname=d.get('hostname'),
10096            id=d.get('id'),
10097            name=d.get('name'),
10098            port=d.get('port'),
10099            port_override=d.get('port_override'),
10100            secret_store_id=d.get('secret_store_id'),
10101            tags=d.get('tags'),
10102        )
10103
10104
10105class Redis:
10106    '''
10107
10108    '''
10109    __slots__ = [
10110        'bind_interface',
10111        'egress_filter',
10112        'healthy',
10113        'hostname',
10114        'id',
10115        'name',
10116        'password',
10117        'port',
10118        'port_override',
10119        'secret_store_id',
10120        'tags',
10121    ]
10122
10123    def __init__(
10124        self,
10125        bind_interface=None,
10126        egress_filter=None,
10127        healthy=None,
10128        hostname=None,
10129        id=None,
10130        name=None,
10131        password=None,
10132        port=None,
10133        port_override=None,
10134        secret_store_id=None,
10135        tags=None,
10136    ):
10137        self.bind_interface = bind_interface if bind_interface is not None else ''
10138        '''
10139         Bind interface
10140        '''
10141        self.egress_filter = egress_filter if egress_filter is not None else ''
10142        '''
10143         A filter applied to the routing logic to pin datasource to nodes.
10144        '''
10145        self.healthy = healthy if healthy is not None else False
10146        '''
10147         True if the datasource is reachable and the credentials are valid.
10148        '''
10149        self.hostname = hostname if hostname is not None else ''
10150        '''
10151
10152        '''
10153        self.id = id if id is not None else ''
10154        '''
10155         Unique identifier of the Resource.
10156        '''
10157        self.name = name if name is not None else ''
10158        '''
10159         Unique human-readable name of the Resource.
10160        '''
10161        self.password = password if password is not None else ''
10162        '''
10163
10164        '''
10165        self.port = port if port is not None else 0
10166        '''
10167
10168        '''
10169        self.port_override = port_override if port_override is not None else 0
10170        '''
10171
10172        '''
10173        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10174        '''
10175         ID of the secret store containing credentials for this resource, if any.
10176        '''
10177        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10178        '''
10179         Tags is a map of key, value pairs.
10180        '''
10181
10182    def __repr__(self):
10183        return '<sdm.Redis ' + \
10184            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10185            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10186            'healthy: ' + repr(self.healthy) + ' ' +\
10187            'hostname: ' + repr(self.hostname) + ' ' +\
10188            'id: ' + repr(self.id) + ' ' +\
10189            'name: ' + repr(self.name) + ' ' +\
10190            'password: ' + repr(self.password) + ' ' +\
10191            'port: ' + repr(self.port) + ' ' +\
10192            'port_override: ' + repr(self.port_override) + ' ' +\
10193            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10194            'tags: ' + repr(self.tags) + ' ' +\
10195            '>'
10196
10197    def to_dict(self):
10198        return {
10199            'bind_interface': self.bind_interface,
10200            'egress_filter': self.egress_filter,
10201            'healthy': self.healthy,
10202            'hostname': self.hostname,
10203            'id': self.id,
10204            'name': self.name,
10205            'password': self.password,
10206            'port': self.port,
10207            'port_override': self.port_override,
10208            'secret_store_id': self.secret_store_id,
10209            'tags': self.tags,
10210        }
10211
10212    @classmethod
10213    def from_dict(cls, d):
10214        return cls(
10215            bind_interface=d.get('bind_interface'),
10216            egress_filter=d.get('egress_filter'),
10217            healthy=d.get('healthy'),
10218            hostname=d.get('hostname'),
10219            id=d.get('id'),
10220            name=d.get('name'),
10221            password=d.get('password'),
10222            port=d.get('port'),
10223            port_override=d.get('port_override'),
10224            secret_store_id=d.get('secret_store_id'),
10225            tags=d.get('tags'),
10226        )
10227
10228
10229class Redshift:
10230    '''
10231
10232    '''
10233    __slots__ = [
10234        'bind_interface',
10235        'database',
10236        'egress_filter',
10237        'healthy',
10238        'hostname',
10239        'id',
10240        'name',
10241        'override_database',
10242        'password',
10243        'port',
10244        'port_override',
10245        'secret_store_id',
10246        'tags',
10247        'username',
10248    ]
10249
10250    def __init__(
10251        self,
10252        bind_interface=None,
10253        database=None,
10254        egress_filter=None,
10255        healthy=None,
10256        hostname=None,
10257        id=None,
10258        name=None,
10259        override_database=None,
10260        password=None,
10261        port=None,
10262        port_override=None,
10263        secret_store_id=None,
10264        tags=None,
10265        username=None,
10266    ):
10267        self.bind_interface = bind_interface if bind_interface is not None else ''
10268        '''
10269         Bind interface
10270        '''
10271        self.database = database if database is not None else ''
10272        '''
10273
10274        '''
10275        self.egress_filter = egress_filter if egress_filter is not None else ''
10276        '''
10277         A filter applied to the routing logic to pin datasource to nodes.
10278        '''
10279        self.healthy = healthy if healthy is not None else False
10280        '''
10281         True if the datasource is reachable and the credentials are valid.
10282        '''
10283        self.hostname = hostname if hostname is not None else ''
10284        '''
10285
10286        '''
10287        self.id = id if id is not None else ''
10288        '''
10289         Unique identifier of the Resource.
10290        '''
10291        self.name = name if name is not None else ''
10292        '''
10293         Unique human-readable name of the Resource.
10294        '''
10295        self.override_database = override_database if override_database is not None else False
10296        '''
10297
10298        '''
10299        self.password = password if password is not None else ''
10300        '''
10301
10302        '''
10303        self.port = port if port is not None else 0
10304        '''
10305
10306        '''
10307        self.port_override = port_override if port_override is not None else 0
10308        '''
10309
10310        '''
10311        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10312        '''
10313         ID of the secret store containing credentials for this resource, if any.
10314        '''
10315        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10316        '''
10317         Tags is a map of key, value pairs.
10318        '''
10319        self.username = username if username is not None else ''
10320        '''
10321
10322        '''
10323
10324    def __repr__(self):
10325        return '<sdm.Redshift ' + \
10326            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10327            'database: ' + repr(self.database) + ' ' +\
10328            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10329            'healthy: ' + repr(self.healthy) + ' ' +\
10330            'hostname: ' + repr(self.hostname) + ' ' +\
10331            'id: ' + repr(self.id) + ' ' +\
10332            'name: ' + repr(self.name) + ' ' +\
10333            'override_database: ' + repr(self.override_database) + ' ' +\
10334            'password: ' + repr(self.password) + ' ' +\
10335            'port: ' + repr(self.port) + ' ' +\
10336            'port_override: ' + repr(self.port_override) + ' ' +\
10337            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10338            'tags: ' + repr(self.tags) + ' ' +\
10339            'username: ' + repr(self.username) + ' ' +\
10340            '>'
10341
10342    def to_dict(self):
10343        return {
10344            'bind_interface': self.bind_interface,
10345            'database': self.database,
10346            'egress_filter': self.egress_filter,
10347            'healthy': self.healthy,
10348            'hostname': self.hostname,
10349            'id': self.id,
10350            'name': self.name,
10351            'override_database': self.override_database,
10352            'password': self.password,
10353            'port': self.port,
10354            'port_override': self.port_override,
10355            'secret_store_id': self.secret_store_id,
10356            'tags': self.tags,
10357            'username': self.username,
10358        }
10359
10360    @classmethod
10361    def from_dict(cls, d):
10362        return cls(
10363            bind_interface=d.get('bind_interface'),
10364            database=d.get('database'),
10365            egress_filter=d.get('egress_filter'),
10366            healthy=d.get('healthy'),
10367            hostname=d.get('hostname'),
10368            id=d.get('id'),
10369            name=d.get('name'),
10370            override_database=d.get('override_database'),
10371            password=d.get('password'),
10372            port=d.get('port'),
10373            port_override=d.get('port_override'),
10374            secret_store_id=d.get('secret_store_id'),
10375            tags=d.get('tags'),
10376            username=d.get('username'),
10377        )
10378
10379
10380class Relay:
10381    '''
10382     Relay represents a StrongDM CLI installation running in relay mode.
10383    '''
10384    __slots__ = [
10385        'gateway_filter',
10386        'id',
10387        'name',
10388        'state',
10389        'tags',
10390    ]
10391
10392    def __init__(
10393        self,
10394        gateway_filter=None,
10395        id=None,
10396        name=None,
10397        state=None,
10398        tags=None,
10399    ):
10400        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
10401        '''
10402         GatewayFilter can be used to restrict the peering between relays and
10403         gateways.
10404        '''
10405        self.id = id if id is not None else ''
10406        '''
10407         Unique identifier of the Relay.
10408        '''
10409        self.name = name if name is not None else ''
10410        '''
10411         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
10412        '''
10413        self.state = state if state is not None else ''
10414        '''
10415         The current state of the relay. One of: "new", "verifying_restart",
10416         "awaiting_restart", "restarting", "started", "stopped", "dead",
10417         "unknown".
10418        '''
10419        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10420        '''
10421         Tags is a map of key, value pairs.
10422        '''
10423
10424    def __repr__(self):
10425        return '<sdm.Relay ' + \
10426            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
10427            'id: ' + repr(self.id) + ' ' +\
10428            'name: ' + repr(self.name) + ' ' +\
10429            'state: ' + repr(self.state) + ' ' +\
10430            'tags: ' + repr(self.tags) + ' ' +\
10431            '>'
10432
10433    def to_dict(self):
10434        return {
10435            'gateway_filter': self.gateway_filter,
10436            'id': self.id,
10437            'name': self.name,
10438            'state': self.state,
10439            'tags': self.tags,
10440        }
10441
10442    @classmethod
10443    def from_dict(cls, d):
10444        return cls(
10445            gateway_filter=d.get('gateway_filter'),
10446            id=d.get('id'),
10447            name=d.get('name'),
10448            state=d.get('state'),
10449            tags=d.get('tags'),
10450        )
10451
10452
10453class RemoteIdentity:
10454    '''
10455     RemoteIdentities define the username to be used for a specific account
10456     when connecting to a remote resource using that group.
10457    '''
10458    __slots__ = [
10459        'account_id',
10460        'id',
10461        'remote_identity_group_id',
10462        'username',
10463    ]
10464
10465    def __init__(
10466        self,
10467        account_id=None,
10468        id=None,
10469        remote_identity_group_id=None,
10470        username=None,
10471    ):
10472        self.account_id = account_id if account_id is not None else ''
10473        '''
10474         The account for this remote identity.
10475        '''
10476        self.id = id if id is not None else ''
10477        '''
10478         Unique identifier of the RemoteIdentity.
10479        '''
10480        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
10481        '''
10482         The remote identity group.
10483        '''
10484        self.username = username if username is not None else ''
10485        '''
10486         The username to be used as the remote identity for this account.
10487        '''
10488
10489    def __repr__(self):
10490        return '<sdm.RemoteIdentity ' + \
10491            'account_id: ' + repr(self.account_id) + ' ' +\
10492            'id: ' + repr(self.id) + ' ' +\
10493            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
10494            'username: ' + repr(self.username) + ' ' +\
10495            '>'
10496
10497    def to_dict(self):
10498        return {
10499            'account_id': self.account_id,
10500            'id': self.id,
10501            'remote_identity_group_id': self.remote_identity_group_id,
10502            'username': self.username,
10503        }
10504
10505    @classmethod
10506    def from_dict(cls, d):
10507        return cls(
10508            account_id=d.get('account_id'),
10509            id=d.get('id'),
10510            remote_identity_group_id=d.get('remote_identity_group_id'),
10511            username=d.get('username'),
10512        )
10513
10514
10515class RemoteIdentityCreateResponse:
10516    '''
10517     RemoteIdentityCreateResponse reports how the RemoteIdentities were created in the system.
10518    '''
10519    __slots__ = [
10520        'meta',
10521        'rate_limit',
10522        'remote_identity',
10523    ]
10524
10525    def __init__(
10526        self,
10527        meta=None,
10528        rate_limit=None,
10529        remote_identity=None,
10530    ):
10531        self.meta = meta if meta is not None else None
10532        '''
10533         Reserved for future use.
10534        '''
10535        self.rate_limit = rate_limit if rate_limit is not None else None
10536        '''
10537         Rate limit information.
10538        '''
10539        self.remote_identity = remote_identity if remote_identity is not None else None
10540        '''
10541         The created RemoteIdentity.
10542        '''
10543
10544    def __repr__(self):
10545        return '<sdm.RemoteIdentityCreateResponse ' + \
10546            'meta: ' + repr(self.meta) + ' ' +\
10547            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10548            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10549            '>'
10550
10551    def to_dict(self):
10552        return {
10553            'meta': self.meta,
10554            'rate_limit': self.rate_limit,
10555            'remote_identity': self.remote_identity,
10556        }
10557
10558    @classmethod
10559    def from_dict(cls, d):
10560        return cls(
10561            meta=d.get('meta'),
10562            rate_limit=d.get('rate_limit'),
10563            remote_identity=d.get('remote_identity'),
10564        )
10565
10566
10567class RemoteIdentityDeleteResponse:
10568    '''
10569     RemoteIdentityDeleteResponse returns information about a RemoteIdentity that was deleted.
10570    '''
10571    __slots__ = [
10572        'meta',
10573        'rate_limit',
10574    ]
10575
10576    def __init__(
10577        self,
10578        meta=None,
10579        rate_limit=None,
10580    ):
10581        self.meta = meta if meta is not None else None
10582        '''
10583         Reserved for future use.
10584        '''
10585        self.rate_limit = rate_limit if rate_limit is not None else None
10586        '''
10587         Rate limit information.
10588        '''
10589
10590    def __repr__(self):
10591        return '<sdm.RemoteIdentityDeleteResponse ' + \
10592            'meta: ' + repr(self.meta) + ' ' +\
10593            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10594            '>'
10595
10596    def to_dict(self):
10597        return {
10598            'meta': self.meta,
10599            'rate_limit': self.rate_limit,
10600        }
10601
10602    @classmethod
10603    def from_dict(cls, d):
10604        return cls(
10605            meta=d.get('meta'),
10606            rate_limit=d.get('rate_limit'),
10607        )
10608
10609
10610class RemoteIdentityGetResponse:
10611    '''
10612     RemoteIdentityGetResponse returns a requested RemoteIdentity.
10613    '''
10614    __slots__ = [
10615        'meta',
10616        'rate_limit',
10617        'remote_identity',
10618    ]
10619
10620    def __init__(
10621        self,
10622        meta=None,
10623        rate_limit=None,
10624        remote_identity=None,
10625    ):
10626        self.meta = meta if meta is not None else None
10627        '''
10628         Reserved for future use.
10629        '''
10630        self.rate_limit = rate_limit if rate_limit is not None else None
10631        '''
10632         Rate limit information.
10633        '''
10634        self.remote_identity = remote_identity if remote_identity is not None else None
10635        '''
10636         The requested RemoteIdentity.
10637        '''
10638
10639    def __repr__(self):
10640        return '<sdm.RemoteIdentityGetResponse ' + \
10641            'meta: ' + repr(self.meta) + ' ' +\
10642            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10643            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10644            '>'
10645
10646    def to_dict(self):
10647        return {
10648            'meta': self.meta,
10649            'rate_limit': self.rate_limit,
10650            'remote_identity': self.remote_identity,
10651        }
10652
10653    @classmethod
10654    def from_dict(cls, d):
10655        return cls(
10656            meta=d.get('meta'),
10657            rate_limit=d.get('rate_limit'),
10658            remote_identity=d.get('remote_identity'),
10659        )
10660
10661
10662class RemoteIdentityGroup:
10663    '''
10664     A RemoteIdentityGroup defines a group of remote identities.
10665    '''
10666    __slots__ = [
10667        'id',
10668        'name',
10669    ]
10670
10671    def __init__(
10672        self,
10673        id=None,
10674        name=None,
10675    ):
10676        self.id = id if id is not None else ''
10677        '''
10678         Unique identifier of the RemoteIdentityGroup.
10679        '''
10680        self.name = name if name is not None else ''
10681        '''
10682         Unique human-readable name of the RemoteIdentityGroup.
10683        '''
10684
10685    def __repr__(self):
10686        return '<sdm.RemoteIdentityGroup ' + \
10687            'id: ' + repr(self.id) + ' ' +\
10688            'name: ' + repr(self.name) + ' ' +\
10689            '>'
10690
10691    def to_dict(self):
10692        return {
10693            'id': self.id,
10694            'name': self.name,
10695        }
10696
10697    @classmethod
10698    def from_dict(cls, d):
10699        return cls(
10700            id=d.get('id'),
10701            name=d.get('name'),
10702        )
10703
10704
10705class RemoteIdentityGroupGetResponse:
10706    '''
10707     RemoteIdentityGroupGetResponse returns a requested RemoteIdentityGroup.
10708    '''
10709    __slots__ = [
10710        'meta',
10711        'rate_limit',
10712        'remote_identity_group',
10713    ]
10714
10715    def __init__(
10716        self,
10717        meta=None,
10718        rate_limit=None,
10719        remote_identity_group=None,
10720    ):
10721        self.meta = meta if meta is not None else None
10722        '''
10723         Reserved for future use.
10724        '''
10725        self.rate_limit = rate_limit if rate_limit is not None else None
10726        '''
10727         Rate limit information.
10728        '''
10729        self.remote_identity_group = remote_identity_group if remote_identity_group is not None else None
10730        '''
10731         The requested RemoteIdentityGroup.
10732        '''
10733
10734    def __repr__(self):
10735        return '<sdm.RemoteIdentityGroupGetResponse ' + \
10736            'meta: ' + repr(self.meta) + ' ' +\
10737            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10738            'remote_identity_group: ' + repr(self.remote_identity_group) + ' ' +\
10739            '>'
10740
10741    def to_dict(self):
10742        return {
10743            'meta': self.meta,
10744            'rate_limit': self.rate_limit,
10745            'remote_identity_group': self.remote_identity_group,
10746        }
10747
10748    @classmethod
10749    def from_dict(cls, d):
10750        return cls(
10751            meta=d.get('meta'),
10752            rate_limit=d.get('rate_limit'),
10753            remote_identity_group=d.get('remote_identity_group'),
10754        )
10755
10756
10757class RemoteIdentityUpdateResponse:
10758    '''
10759     RemoteIdentityUpdateResponse returns the fields of a RemoteIdentity after it has been updated by
10760     a RemoteIdentityUpdateRequest.
10761    '''
10762    __slots__ = [
10763        'meta',
10764        'rate_limit',
10765        'remote_identity',
10766    ]
10767
10768    def __init__(
10769        self,
10770        meta=None,
10771        rate_limit=None,
10772        remote_identity=None,
10773    ):
10774        self.meta = meta if meta is not None else None
10775        '''
10776         Reserved for future use.
10777        '''
10778        self.rate_limit = rate_limit if rate_limit is not None else None
10779        '''
10780         Rate limit information.
10781        '''
10782        self.remote_identity = remote_identity if remote_identity is not None else None
10783        '''
10784         The updated RemoteIdentity.
10785        '''
10786
10787    def __repr__(self):
10788        return '<sdm.RemoteIdentityUpdateResponse ' + \
10789            'meta: ' + repr(self.meta) + ' ' +\
10790            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10791            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10792            '>'
10793
10794    def to_dict(self):
10795        return {
10796            'meta': self.meta,
10797            'rate_limit': self.rate_limit,
10798            'remote_identity': self.remote_identity,
10799        }
10800
10801    @classmethod
10802    def from_dict(cls, d):
10803        return cls(
10804            meta=d.get('meta'),
10805            rate_limit=d.get('rate_limit'),
10806            remote_identity=d.get('remote_identity'),
10807        )
10808
10809
10810class ResourceCreateResponse:
10811    '''
10812     ResourceCreateResponse reports how the Resources were created in the system.
10813    '''
10814    __slots__ = [
10815        'meta',
10816        'rate_limit',
10817        'resource',
10818    ]
10819
10820    def __init__(
10821        self,
10822        meta=None,
10823        rate_limit=None,
10824        resource=None,
10825    ):
10826        self.meta = meta if meta is not None else None
10827        '''
10828         Reserved for future use.
10829        '''
10830        self.rate_limit = rate_limit if rate_limit is not None else None
10831        '''
10832         Rate limit information.
10833        '''
10834        self.resource = resource if resource is not None else None
10835        '''
10836         The created Resource.
10837        '''
10838
10839    def __repr__(self):
10840        return '<sdm.ResourceCreateResponse ' + \
10841            'meta: ' + repr(self.meta) + ' ' +\
10842            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10843            'resource: ' + repr(self.resource) + ' ' +\
10844            '>'
10845
10846    def to_dict(self):
10847        return {
10848            'meta': self.meta,
10849            'rate_limit': self.rate_limit,
10850            'resource': self.resource,
10851        }
10852
10853    @classmethod
10854    def from_dict(cls, d):
10855        return cls(
10856            meta=d.get('meta'),
10857            rate_limit=d.get('rate_limit'),
10858            resource=d.get('resource'),
10859        )
10860
10861
10862class ResourceDeleteResponse:
10863    '''
10864     ResourceDeleteResponse returns information about a Resource that was deleted.
10865    '''
10866    __slots__ = [
10867        'meta',
10868        'rate_limit',
10869    ]
10870
10871    def __init__(
10872        self,
10873        meta=None,
10874        rate_limit=None,
10875    ):
10876        self.meta = meta if meta is not None else None
10877        '''
10878         Reserved for future use.
10879        '''
10880        self.rate_limit = rate_limit if rate_limit is not None else None
10881        '''
10882         Rate limit information.
10883        '''
10884
10885    def __repr__(self):
10886        return '<sdm.ResourceDeleteResponse ' + \
10887            'meta: ' + repr(self.meta) + ' ' +\
10888            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10889            '>'
10890
10891    def to_dict(self):
10892        return {
10893            'meta': self.meta,
10894            'rate_limit': self.rate_limit,
10895        }
10896
10897    @classmethod
10898    def from_dict(cls, d):
10899        return cls(
10900            meta=d.get('meta'),
10901            rate_limit=d.get('rate_limit'),
10902        )
10903
10904
10905class ResourceGetResponse:
10906    '''
10907     ResourceGetResponse returns a requested Resource.
10908    '''
10909    __slots__ = [
10910        'meta',
10911        'rate_limit',
10912        'resource',
10913    ]
10914
10915    def __init__(
10916        self,
10917        meta=None,
10918        rate_limit=None,
10919        resource=None,
10920    ):
10921        self.meta = meta if meta is not None else None
10922        '''
10923         Reserved for future use.
10924        '''
10925        self.rate_limit = rate_limit if rate_limit is not None else None
10926        '''
10927         Rate limit information.
10928        '''
10929        self.resource = resource if resource is not None else None
10930        '''
10931         The requested Resource.
10932        '''
10933
10934    def __repr__(self):
10935        return '<sdm.ResourceGetResponse ' + \
10936            'meta: ' + repr(self.meta) + ' ' +\
10937            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10938            'resource: ' + repr(self.resource) + ' ' +\
10939            '>'
10940
10941    def to_dict(self):
10942        return {
10943            'meta': self.meta,
10944            'rate_limit': self.rate_limit,
10945            'resource': self.resource,
10946        }
10947
10948    @classmethod
10949    def from_dict(cls, d):
10950        return cls(
10951            meta=d.get('meta'),
10952            rate_limit=d.get('rate_limit'),
10953            resource=d.get('resource'),
10954        )
10955
10956
10957class ResourceUpdateResponse:
10958    '''
10959     ResourceUpdateResponse returns the fields of a Resource after it has been updated by
10960     a ResourceUpdateRequest.
10961    '''
10962    __slots__ = [
10963        'meta',
10964        'rate_limit',
10965        'resource',
10966    ]
10967
10968    def __init__(
10969        self,
10970        meta=None,
10971        rate_limit=None,
10972        resource=None,
10973    ):
10974        self.meta = meta if meta is not None else None
10975        '''
10976         Reserved for future use.
10977        '''
10978        self.rate_limit = rate_limit if rate_limit is not None else None
10979        '''
10980         Rate limit information.
10981        '''
10982        self.resource = resource if resource is not None else None
10983        '''
10984         The updated Resource.
10985        '''
10986
10987    def __repr__(self):
10988        return '<sdm.ResourceUpdateResponse ' + \
10989            'meta: ' + repr(self.meta) + ' ' +\
10990            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10991            'resource: ' + repr(self.resource) + ' ' +\
10992            '>'
10993
10994    def to_dict(self):
10995        return {
10996            'meta': self.meta,
10997            'rate_limit': self.rate_limit,
10998            'resource': self.resource,
10999        }
11000
11001    @classmethod
11002    def from_dict(cls, d):
11003        return cls(
11004            meta=d.get('meta'),
11005            rate_limit=d.get('rate_limit'),
11006            resource=d.get('resource'),
11007        )
11008
11009
11010class Role:
11011    '''
11012     A Role has a list of access rules which determine which Resources the members
11013     of the Role have access to. An Account can be a member of multiple Roles via
11014     AccountAttachments.
11015    '''
11016    __slots__ = [
11017        'access_rules',
11018        'id',
11019        'name',
11020        'tags',
11021    ]
11022
11023    def __init__(
11024        self,
11025        access_rules=None,
11026        id=None,
11027        name=None,
11028        tags=None,
11029    ):
11030        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
11031        )
11032        '''
11033         AccessRules is a list of access rules defining the resources this Role has access to.
11034        '''
11035        self.id = id if id is not None else ''
11036        '''
11037         Unique identifier of the Role.
11038        '''
11039        self.name = name if name is not None else ''
11040        '''
11041         Unique human-readable name of the Role.
11042        '''
11043        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11044        '''
11045         Tags is a map of key, value pairs.
11046        '''
11047
11048    def __repr__(self):
11049        return '<sdm.Role ' + \
11050            'access_rules: ' + repr(self.access_rules) + ' ' +\
11051            'id: ' + repr(self.id) + ' ' +\
11052            'name: ' + repr(self.name) + ' ' +\
11053            'tags: ' + repr(self.tags) + ' ' +\
11054            '>'
11055
11056    def to_dict(self):
11057        return {
11058            'access_rules': self.access_rules,
11059            'id': self.id,
11060            'name': self.name,
11061            'tags': self.tags,
11062        }
11063
11064    @classmethod
11065    def from_dict(cls, d):
11066        return cls(
11067            access_rules=d.get('access_rules'),
11068            id=d.get('id'),
11069            name=d.get('name'),
11070            tags=d.get('tags'),
11071        )
11072
11073
11074class RoleCreateResponse:
11075    '''
11076     RoleCreateResponse reports how the Roles were created in the system. It can
11077     communicate partial successes or failures.
11078    '''
11079    __slots__ = [
11080        'meta',
11081        'rate_limit',
11082        'role',
11083    ]
11084
11085    def __init__(
11086        self,
11087        meta=None,
11088        rate_limit=None,
11089        role=None,
11090    ):
11091        self.meta = meta if meta is not None else None
11092        '''
11093         Reserved for future use.
11094        '''
11095        self.rate_limit = rate_limit if rate_limit is not None else None
11096        '''
11097         Rate limit information.
11098        '''
11099        self.role = role if role is not None else None
11100        '''
11101         The created Role.
11102        '''
11103
11104    def __repr__(self):
11105        return '<sdm.RoleCreateResponse ' + \
11106            'meta: ' + repr(self.meta) + ' ' +\
11107            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11108            'role: ' + repr(self.role) + ' ' +\
11109            '>'
11110
11111    def to_dict(self):
11112        return {
11113            'meta': self.meta,
11114            'rate_limit': self.rate_limit,
11115            'role': self.role,
11116        }
11117
11118    @classmethod
11119    def from_dict(cls, d):
11120        return cls(
11121            meta=d.get('meta'),
11122            rate_limit=d.get('rate_limit'),
11123            role=d.get('role'),
11124        )
11125
11126
11127class RoleDeleteResponse:
11128    '''
11129     RoleDeleteResponse returns information about a Role that was deleted.
11130    '''
11131    __slots__ = [
11132        'meta',
11133        'rate_limit',
11134    ]
11135
11136    def __init__(
11137        self,
11138        meta=None,
11139        rate_limit=None,
11140    ):
11141        self.meta = meta if meta is not None else None
11142        '''
11143         Reserved for future use.
11144        '''
11145        self.rate_limit = rate_limit if rate_limit is not None else None
11146        '''
11147         Rate limit information.
11148        '''
11149
11150    def __repr__(self):
11151        return '<sdm.RoleDeleteResponse ' + \
11152            'meta: ' + repr(self.meta) + ' ' +\
11153            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11154            '>'
11155
11156    def to_dict(self):
11157        return {
11158            'meta': self.meta,
11159            'rate_limit': self.rate_limit,
11160        }
11161
11162    @classmethod
11163    def from_dict(cls, d):
11164        return cls(
11165            meta=d.get('meta'),
11166            rate_limit=d.get('rate_limit'),
11167        )
11168
11169
11170class RoleGetResponse:
11171    '''
11172     RoleGetResponse returns a requested Role.
11173    '''
11174    __slots__ = [
11175        'meta',
11176        'rate_limit',
11177        'role',
11178    ]
11179
11180    def __init__(
11181        self,
11182        meta=None,
11183        rate_limit=None,
11184        role=None,
11185    ):
11186        self.meta = meta if meta is not None else None
11187        '''
11188         Reserved for future use.
11189        '''
11190        self.rate_limit = rate_limit if rate_limit is not None else None
11191        '''
11192         Rate limit information.
11193        '''
11194        self.role = role if role is not None else None
11195        '''
11196         The requested Role.
11197        '''
11198
11199    def __repr__(self):
11200        return '<sdm.RoleGetResponse ' + \
11201            'meta: ' + repr(self.meta) + ' ' +\
11202            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11203            'role: ' + repr(self.role) + ' ' +\
11204            '>'
11205
11206    def to_dict(self):
11207        return {
11208            'meta': self.meta,
11209            'rate_limit': self.rate_limit,
11210            'role': self.role,
11211        }
11212
11213    @classmethod
11214    def from_dict(cls, d):
11215        return cls(
11216            meta=d.get('meta'),
11217            rate_limit=d.get('rate_limit'),
11218            role=d.get('role'),
11219        )
11220
11221
11222class RoleUpdateResponse:
11223    '''
11224     RoleUpdateResponse returns the fields of a Role after it has been updated by
11225     a RoleUpdateRequest.
11226    '''
11227    __slots__ = [
11228        'meta',
11229        'rate_limit',
11230        'role',
11231    ]
11232
11233    def __init__(
11234        self,
11235        meta=None,
11236        rate_limit=None,
11237        role=None,
11238    ):
11239        self.meta = meta if meta is not None else None
11240        '''
11241         Reserved for future use.
11242        '''
11243        self.rate_limit = rate_limit if rate_limit is not None else None
11244        '''
11245         Rate limit information.
11246        '''
11247        self.role = role if role is not None else None
11248        '''
11249         The updated Role.
11250        '''
11251
11252    def __repr__(self):
11253        return '<sdm.RoleUpdateResponse ' + \
11254            'meta: ' + repr(self.meta) + ' ' +\
11255            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11256            'role: ' + repr(self.role) + ' ' +\
11257            '>'
11258
11259    def to_dict(self):
11260        return {
11261            'meta': self.meta,
11262            'rate_limit': self.rate_limit,
11263            'role': self.role,
11264        }
11265
11266    @classmethod
11267    def from_dict(cls, d):
11268        return cls(
11269            meta=d.get('meta'),
11270            rate_limit=d.get('rate_limit'),
11271            role=d.get('role'),
11272        )
11273
11274
11275class SQLServer:
11276    '''
11277
11278    '''
11279    __slots__ = [
11280        'bind_interface',
11281        'database',
11282        'egress_filter',
11283        'healthy',
11284        'hostname',
11285        'id',
11286        'name',
11287        'override_database',
11288        'password',
11289        'port',
11290        'port_override',
11291        'schema',
11292        'secret_store_id',
11293        'tags',
11294        'username',
11295    ]
11296
11297    def __init__(
11298        self,
11299        bind_interface=None,
11300        database=None,
11301        egress_filter=None,
11302        healthy=None,
11303        hostname=None,
11304        id=None,
11305        name=None,
11306        override_database=None,
11307        password=None,
11308        port=None,
11309        port_override=None,
11310        schema=None,
11311        secret_store_id=None,
11312        tags=None,
11313        username=None,
11314    ):
11315        self.bind_interface = bind_interface if bind_interface is not None else ''
11316        '''
11317         Bind interface
11318        '''
11319        self.database = database if database is not None else ''
11320        '''
11321
11322        '''
11323        self.egress_filter = egress_filter if egress_filter is not None else ''
11324        '''
11325         A filter applied to the routing logic to pin datasource to nodes.
11326        '''
11327        self.healthy = healthy if healthy is not None else False
11328        '''
11329         True if the datasource is reachable and the credentials are valid.
11330        '''
11331        self.hostname = hostname if hostname is not None else ''
11332        '''
11333
11334        '''
11335        self.id = id if id is not None else ''
11336        '''
11337         Unique identifier of the Resource.
11338        '''
11339        self.name = name if name is not None else ''
11340        '''
11341         Unique human-readable name of the Resource.
11342        '''
11343        self.override_database = override_database if override_database is not None else False
11344        '''
11345
11346        '''
11347        self.password = password if password is not None else ''
11348        '''
11349
11350        '''
11351        self.port = port if port is not None else 0
11352        '''
11353
11354        '''
11355        self.port_override = port_override if port_override is not None else 0
11356        '''
11357
11358        '''
11359        self.schema = schema if schema is not None else ''
11360        '''
11361
11362        '''
11363        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11364        '''
11365         ID of the secret store containing credentials for this resource, if any.
11366        '''
11367        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11368        '''
11369         Tags is a map of key, value pairs.
11370        '''
11371        self.username = username if username is not None else ''
11372        '''
11373
11374        '''
11375
11376    def __repr__(self):
11377        return '<sdm.SQLServer ' + \
11378            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11379            'database: ' + repr(self.database) + ' ' +\
11380            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11381            'healthy: ' + repr(self.healthy) + ' ' +\
11382            'hostname: ' + repr(self.hostname) + ' ' +\
11383            'id: ' + repr(self.id) + ' ' +\
11384            'name: ' + repr(self.name) + ' ' +\
11385            'override_database: ' + repr(self.override_database) + ' ' +\
11386            'password: ' + repr(self.password) + ' ' +\
11387            'port: ' + repr(self.port) + ' ' +\
11388            'port_override: ' + repr(self.port_override) + ' ' +\
11389            'schema: ' + repr(self.schema) + ' ' +\
11390            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11391            'tags: ' + repr(self.tags) + ' ' +\
11392            'username: ' + repr(self.username) + ' ' +\
11393            '>'
11394
11395    def to_dict(self):
11396        return {
11397            'bind_interface': self.bind_interface,
11398            'database': self.database,
11399            'egress_filter': self.egress_filter,
11400            'healthy': self.healthy,
11401            'hostname': self.hostname,
11402            'id': self.id,
11403            'name': self.name,
11404            'override_database': self.override_database,
11405            'password': self.password,
11406            'port': self.port,
11407            'port_override': self.port_override,
11408            'schema': self.schema,
11409            'secret_store_id': self.secret_store_id,
11410            'tags': self.tags,
11411            'username': self.username,
11412        }
11413
11414    @classmethod
11415    def from_dict(cls, d):
11416        return cls(
11417            bind_interface=d.get('bind_interface'),
11418            database=d.get('database'),
11419            egress_filter=d.get('egress_filter'),
11420            healthy=d.get('healthy'),
11421            hostname=d.get('hostname'),
11422            id=d.get('id'),
11423            name=d.get('name'),
11424            override_database=d.get('override_database'),
11425            password=d.get('password'),
11426            port=d.get('port'),
11427            port_override=d.get('port_override'),
11428            schema=d.get('schema'),
11429            secret_store_id=d.get('secret_store_id'),
11430            tags=d.get('tags'),
11431            username=d.get('username'),
11432        )
11433
11434
11435class SSH:
11436    '''
11437
11438    '''
11439    __slots__ = [
11440        'allow_deprecated_key_exchanges',
11441        'bind_interface',
11442        'egress_filter',
11443        'healthy',
11444        'hostname',
11445        'id',
11446        'key_type',
11447        'name',
11448        'port',
11449        'port_forwarding',
11450        'port_override',
11451        'public_key',
11452        'secret_store_id',
11453        'tags',
11454        'username',
11455    ]
11456
11457    def __init__(
11458        self,
11459        allow_deprecated_key_exchanges=None,
11460        bind_interface=None,
11461        egress_filter=None,
11462        healthy=None,
11463        hostname=None,
11464        id=None,
11465        key_type=None,
11466        name=None,
11467        port=None,
11468        port_forwarding=None,
11469        port_override=None,
11470        public_key=None,
11471        secret_store_id=None,
11472        tags=None,
11473        username=None,
11474    ):
11475        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11476        '''
11477
11478        '''
11479        self.bind_interface = bind_interface if bind_interface is not None else ''
11480        '''
11481         Bind interface
11482        '''
11483        self.egress_filter = egress_filter if egress_filter is not None else ''
11484        '''
11485         A filter applied to the routing logic to pin datasource to nodes.
11486        '''
11487        self.healthy = healthy if healthy is not None else False
11488        '''
11489         True if the datasource is reachable and the credentials are valid.
11490        '''
11491        self.hostname = hostname if hostname is not None else ''
11492        '''
11493
11494        '''
11495        self.id = id if id is not None else ''
11496        '''
11497         Unique identifier of the Resource.
11498        '''
11499        self.key_type = key_type if key_type is not None else ''
11500        '''
11501
11502        '''
11503        self.name = name if name is not None else ''
11504        '''
11505         Unique human-readable name of the Resource.
11506        '''
11507        self.port = port if port is not None else 0
11508        '''
11509
11510        '''
11511        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11512        '''
11513
11514        '''
11515        self.port_override = port_override if port_override is not None else 0
11516        '''
11517
11518        '''
11519        self.public_key = public_key if public_key is not None else ''
11520        '''
11521
11522        '''
11523        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11524        '''
11525         ID of the secret store containing credentials for this resource, if any.
11526        '''
11527        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11528        '''
11529         Tags is a map of key, value pairs.
11530        '''
11531        self.username = username if username is not None else ''
11532        '''
11533
11534        '''
11535
11536    def __repr__(self):
11537        return '<sdm.SSH ' + \
11538            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
11539            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11540            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11541            'healthy: ' + repr(self.healthy) + ' ' +\
11542            'hostname: ' + repr(self.hostname) + ' ' +\
11543            'id: ' + repr(self.id) + ' ' +\
11544            'key_type: ' + repr(self.key_type) + ' ' +\
11545            'name: ' + repr(self.name) + ' ' +\
11546            'port: ' + repr(self.port) + ' ' +\
11547            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
11548            'port_override: ' + repr(self.port_override) + ' ' +\
11549            'public_key: ' + repr(self.public_key) + ' ' +\
11550            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11551            'tags: ' + repr(self.tags) + ' ' +\
11552            'username: ' + repr(self.username) + ' ' +\
11553            '>'
11554
11555    def to_dict(self):
11556        return {
11557            'allow_deprecated_key_exchanges':
11558            self.allow_deprecated_key_exchanges,
11559            'bind_interface': self.bind_interface,
11560            'egress_filter': self.egress_filter,
11561            'healthy': self.healthy,
11562            'hostname': self.hostname,
11563            'id': self.id,
11564            'key_type': self.key_type,
11565            'name': self.name,
11566            'port': self.port,
11567            'port_forwarding': self.port_forwarding,
11568            'port_override': self.port_override,
11569            'public_key': self.public_key,
11570            'secret_store_id': self.secret_store_id,
11571            'tags': self.tags,
11572            'username': self.username,
11573        }
11574
11575    @classmethod
11576    def from_dict(cls, d):
11577        return cls(
11578            allow_deprecated_key_exchanges=d.get(
11579                'allow_deprecated_key_exchanges'),
11580            bind_interface=d.get('bind_interface'),
11581            egress_filter=d.get('egress_filter'),
11582            healthy=d.get('healthy'),
11583            hostname=d.get('hostname'),
11584            id=d.get('id'),
11585            key_type=d.get('key_type'),
11586            name=d.get('name'),
11587            port=d.get('port'),
11588            port_forwarding=d.get('port_forwarding'),
11589            port_override=d.get('port_override'),
11590            public_key=d.get('public_key'),
11591            secret_store_id=d.get('secret_store_id'),
11592            tags=d.get('tags'),
11593            username=d.get('username'),
11594        )
11595
11596
11597class SSHCert:
11598    '''
11599
11600    '''
11601    __slots__ = [
11602        'allow_deprecated_key_exchanges',
11603        'bind_interface',
11604        'egress_filter',
11605        'healthy',
11606        'hostname',
11607        'id',
11608        'key_type',
11609        'name',
11610        'port',
11611        'port_forwarding',
11612        'port_override',
11613        'remote_identity_group_id',
11614        'remote_identity_healthcheck_username',
11615        'secret_store_id',
11616        'tags',
11617        'username',
11618    ]
11619
11620    def __init__(
11621        self,
11622        allow_deprecated_key_exchanges=None,
11623        bind_interface=None,
11624        egress_filter=None,
11625        healthy=None,
11626        hostname=None,
11627        id=None,
11628        key_type=None,
11629        name=None,
11630        port=None,
11631        port_forwarding=None,
11632        port_override=None,
11633        remote_identity_group_id=None,
11634        remote_identity_healthcheck_username=None,
11635        secret_store_id=None,
11636        tags=None,
11637        username=None,
11638    ):
11639        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11640        '''
11641
11642        '''
11643        self.bind_interface = bind_interface if bind_interface is not None else ''
11644        '''
11645         Bind interface
11646        '''
11647        self.egress_filter = egress_filter if egress_filter is not None else ''
11648        '''
11649         A filter applied to the routing logic to pin datasource to nodes.
11650        '''
11651        self.healthy = healthy if healthy is not None else False
11652        '''
11653         True if the datasource is reachable and the credentials are valid.
11654        '''
11655        self.hostname = hostname if hostname is not None else ''
11656        '''
11657
11658        '''
11659        self.id = id if id is not None else ''
11660        '''
11661         Unique identifier of the Resource.
11662        '''
11663        self.key_type = key_type if key_type is not None else ''
11664        '''
11665
11666        '''
11667        self.name = name if name is not None else ''
11668        '''
11669         Unique human-readable name of the Resource.
11670        '''
11671        self.port = port if port is not None else 0
11672        '''
11673
11674        '''
11675        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11676        '''
11677
11678        '''
11679        self.port_override = port_override if port_override is not None else 0
11680        '''
11681
11682        '''
11683        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
11684        '''
11685
11686        '''
11687        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
11688        '''
11689
11690        '''
11691        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11692        '''
11693         ID of the secret store containing credentials for this resource, if any.
11694        '''
11695        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11696        '''
11697         Tags is a map of key, value pairs.
11698        '''
11699        self.username = username if username is not None else ''
11700        '''
11701
11702        '''
11703
11704    def __repr__(self):
11705        return '<sdm.SSHCert ' + \
11706            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
11707            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11708            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11709            'healthy: ' + repr(self.healthy) + ' ' +\
11710            'hostname: ' + repr(self.hostname) + ' ' +\
11711            'id: ' + repr(self.id) + ' ' +\
11712            'key_type: ' + repr(self.key_type) + ' ' +\
11713            'name: ' + repr(self.name) + ' ' +\
11714            'port: ' + repr(self.port) + ' ' +\
11715            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
11716            'port_override: ' + repr(self.port_override) + ' ' +\
11717            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
11718            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
11719            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11720            'tags: ' + repr(self.tags) + ' ' +\
11721            'username: ' + repr(self.username) + ' ' +\
11722            '>'
11723
11724    def to_dict(self):
11725        return {
11726            'allow_deprecated_key_exchanges':
11727            self.allow_deprecated_key_exchanges,
11728            'bind_interface': self.bind_interface,
11729            'egress_filter': self.egress_filter,
11730            'healthy': self.healthy,
11731            'hostname': self.hostname,
11732            'id': self.id,
11733            'key_type': self.key_type,
11734            'name': self.name,
11735            'port': self.port,
11736            'port_forwarding': self.port_forwarding,
11737            'port_override': self.port_override,
11738            'remote_identity_group_id': self.remote_identity_group_id,
11739            'remote_identity_healthcheck_username':
11740            self.remote_identity_healthcheck_username,
11741            'secret_store_id': self.secret_store_id,
11742            'tags': self.tags,
11743            'username': self.username,
11744        }
11745
11746    @classmethod
11747    def from_dict(cls, d):
11748        return cls(
11749            allow_deprecated_key_exchanges=d.get(
11750                'allow_deprecated_key_exchanges'),
11751            bind_interface=d.get('bind_interface'),
11752            egress_filter=d.get('egress_filter'),
11753            healthy=d.get('healthy'),
11754            hostname=d.get('hostname'),
11755            id=d.get('id'),
11756            key_type=d.get('key_type'),
11757            name=d.get('name'),
11758            port=d.get('port'),
11759            port_forwarding=d.get('port_forwarding'),
11760            port_override=d.get('port_override'),
11761            remote_identity_group_id=d.get('remote_identity_group_id'),
11762            remote_identity_healthcheck_username=d.get(
11763                'remote_identity_healthcheck_username'),
11764            secret_store_id=d.get('secret_store_id'),
11765            tags=d.get('tags'),
11766            username=d.get('username'),
11767        )
11768
11769
11770class SSHCustomerKey:
11771    '''
11772
11773    '''
11774    __slots__ = [
11775        'allow_deprecated_key_exchanges',
11776        'bind_interface',
11777        'egress_filter',
11778        'healthy',
11779        'hostname',
11780        'id',
11781        'name',
11782        'port',
11783        'port_forwarding',
11784        'port_override',
11785        'private_key',
11786        'secret_store_id',
11787        'tags',
11788        'username',
11789    ]
11790
11791    def __init__(
11792        self,
11793        allow_deprecated_key_exchanges=None,
11794        bind_interface=None,
11795        egress_filter=None,
11796        healthy=None,
11797        hostname=None,
11798        id=None,
11799        name=None,
11800        port=None,
11801        port_forwarding=None,
11802        port_override=None,
11803        private_key=None,
11804        secret_store_id=None,
11805        tags=None,
11806        username=None,
11807    ):
11808        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11809        '''
11810
11811        '''
11812        self.bind_interface = bind_interface if bind_interface is not None else ''
11813        '''
11814         Bind interface
11815        '''
11816        self.egress_filter = egress_filter if egress_filter is not None else ''
11817        '''
11818         A filter applied to the routing logic to pin datasource to nodes.
11819        '''
11820        self.healthy = healthy if healthy is not None else False
11821        '''
11822         True if the datasource is reachable and the credentials are valid.
11823        '''
11824        self.hostname = hostname if hostname is not None else ''
11825        '''
11826
11827        '''
11828        self.id = id if id is not None else ''
11829        '''
11830         Unique identifier of the Resource.
11831        '''
11832        self.name = name if name is not None else ''
11833        '''
11834         Unique human-readable name of the Resource.
11835        '''
11836        self.port = port if port is not None else 0
11837        '''
11838
11839        '''
11840        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11841        '''
11842
11843        '''
11844        self.port_override = port_override if port_override is not None else 0
11845        '''
11846
11847        '''
11848        self.private_key = private_key if private_key is not None else ''
11849        '''
11850
11851        '''
11852        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11853        '''
11854         ID of the secret store containing credentials for this resource, if any.
11855        '''
11856        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11857        '''
11858         Tags is a map of key, value pairs.
11859        '''
11860        self.username = username if username is not None else ''
11861        '''
11862
11863        '''
11864
11865    def __repr__(self):
11866        return '<sdm.SSHCustomerKey ' + \
11867            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
11868            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11869            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11870            'healthy: ' + repr(self.healthy) + ' ' +\
11871            'hostname: ' + repr(self.hostname) + ' ' +\
11872            'id: ' + repr(self.id) + ' ' +\
11873            'name: ' + repr(self.name) + ' ' +\
11874            'port: ' + repr(self.port) + ' ' +\
11875            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
11876            'port_override: ' + repr(self.port_override) + ' ' +\
11877            'private_key: ' + repr(self.private_key) + ' ' +\
11878            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11879            'tags: ' + repr(self.tags) + ' ' +\
11880            'username: ' + repr(self.username) + ' ' +\
11881            '>'
11882
11883    def to_dict(self):
11884        return {
11885            'allow_deprecated_key_exchanges':
11886            self.allow_deprecated_key_exchanges,
11887            'bind_interface': self.bind_interface,
11888            'egress_filter': self.egress_filter,
11889            'healthy': self.healthy,
11890            'hostname': self.hostname,
11891            'id': self.id,
11892            'name': self.name,
11893            'port': self.port,
11894            'port_forwarding': self.port_forwarding,
11895            'port_override': self.port_override,
11896            'private_key': self.private_key,
11897            'secret_store_id': self.secret_store_id,
11898            'tags': self.tags,
11899            'username': self.username,
11900        }
11901
11902    @classmethod
11903    def from_dict(cls, d):
11904        return cls(
11905            allow_deprecated_key_exchanges=d.get(
11906                'allow_deprecated_key_exchanges'),
11907            bind_interface=d.get('bind_interface'),
11908            egress_filter=d.get('egress_filter'),
11909            healthy=d.get('healthy'),
11910            hostname=d.get('hostname'),
11911            id=d.get('id'),
11912            name=d.get('name'),
11913            port=d.get('port'),
11914            port_forwarding=d.get('port_forwarding'),
11915            port_override=d.get('port_override'),
11916            private_key=d.get('private_key'),
11917            secret_store_id=d.get('secret_store_id'),
11918            tags=d.get('tags'),
11919            username=d.get('username'),
11920        )
11921
11922
11923class SecretStoreCreateResponse:
11924    '''
11925     SecretStoreCreateResponse reports how the SecretStores were created in the system.
11926    '''
11927    __slots__ = [
11928        'meta',
11929        'rate_limit',
11930        'secret_store',
11931    ]
11932
11933    def __init__(
11934        self,
11935        meta=None,
11936        rate_limit=None,
11937        secret_store=None,
11938    ):
11939        self.meta = meta if meta is not None else None
11940        '''
11941         Reserved for future use.
11942        '''
11943        self.rate_limit = rate_limit if rate_limit is not None else None
11944        '''
11945         Rate limit information.
11946        '''
11947        self.secret_store = secret_store if secret_store is not None else None
11948        '''
11949         The created SecretStore.
11950        '''
11951
11952    def __repr__(self):
11953        return '<sdm.SecretStoreCreateResponse ' + \
11954            'meta: ' + repr(self.meta) + ' ' +\
11955            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11956            'secret_store: ' + repr(self.secret_store) + ' ' +\
11957            '>'
11958
11959    def to_dict(self):
11960        return {
11961            'meta': self.meta,
11962            'rate_limit': self.rate_limit,
11963            'secret_store': self.secret_store,
11964        }
11965
11966    @classmethod
11967    def from_dict(cls, d):
11968        return cls(
11969            meta=d.get('meta'),
11970            rate_limit=d.get('rate_limit'),
11971            secret_store=d.get('secret_store'),
11972        )
11973
11974
11975class SecretStoreDeleteResponse:
11976    '''
11977     SecretStoreDeleteResponse returns information about a SecretStore that was deleted.
11978    '''
11979    __slots__ = [
11980        'meta',
11981        'rate_limit',
11982    ]
11983
11984    def __init__(
11985        self,
11986        meta=None,
11987        rate_limit=None,
11988    ):
11989        self.meta = meta if meta is not None else None
11990        '''
11991         Reserved for future use.
11992        '''
11993        self.rate_limit = rate_limit if rate_limit is not None else None
11994        '''
11995         Rate limit information.
11996        '''
11997
11998    def __repr__(self):
11999        return '<sdm.SecretStoreDeleteResponse ' + \
12000            'meta: ' + repr(self.meta) + ' ' +\
12001            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
12002            '>'
12003
12004    def to_dict(self):
12005        return {
12006            'meta': self.meta,
12007            'rate_limit': self.rate_limit,
12008        }
12009
12010    @classmethod
12011    def from_dict(cls, d):
12012        return cls(
12013            meta=d.get('meta'),
12014            rate_limit=d.get('rate_limit'),
12015        )
12016
12017
12018class SecretStoreGetResponse:
12019    '''
12020     SecretStoreGetResponse returns a requested SecretStore.
12021    '''
12022    __slots__ = [
12023        'meta',
12024        'rate_limit',
12025        'secret_store',
12026    ]
12027
12028    def __init__(
12029        self,
12030        meta=None,
12031        rate_limit=None,
12032        secret_store=None,
12033    ):
12034        self.meta = meta if meta is not None else None
12035        '''
12036         Reserved for future use.
12037        '''
12038        self.rate_limit = rate_limit if rate_limit is not None else None
12039        '''
12040         Rate limit information.
12041        '''
12042        self.secret_store = secret_store if secret_store is not None else None
12043        '''
12044         The requested SecretStore.
12045        '''
12046
12047    def __repr__(self):
12048        return '<sdm.SecretStoreGetResponse ' + \
12049            'meta: ' + repr(self.meta) + ' ' +\
12050            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
12051            'secret_store: ' + repr(self.secret_store) + ' ' +\
12052            '>'
12053
12054    def to_dict(self):
12055        return {
12056            'meta': self.meta,
12057            'rate_limit': self.rate_limit,
12058            'secret_store': self.secret_store,
12059        }
12060
12061    @classmethod
12062    def from_dict(cls, d):
12063        return cls(
12064            meta=d.get('meta'),
12065            rate_limit=d.get('rate_limit'),
12066            secret_store=d.get('secret_store'),
12067        )
12068
12069
12070class SecretStoreUpdateResponse:
12071    '''
12072     SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by
12073     a SecretStoreUpdateRequest.
12074    '''
12075    __slots__ = [
12076        'meta',
12077        'rate_limit',
12078        'secret_store',
12079    ]
12080
12081    def __init__(
12082        self,
12083        meta=None,
12084        rate_limit=None,
12085        secret_store=None,
12086    ):
12087        self.meta = meta if meta is not None else None
12088        '''
12089         Reserved for future use.
12090        '''
12091        self.rate_limit = rate_limit if rate_limit is not None else None
12092        '''
12093         Rate limit information.
12094        '''
12095        self.secret_store = secret_store if secret_store is not None else None
12096        '''
12097         The updated SecretStore.
12098        '''
12099
12100    def __repr__(self):
12101        return '<sdm.SecretStoreUpdateResponse ' + \
12102            'meta: ' + repr(self.meta) + ' ' +\
12103            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
12104            'secret_store: ' + repr(self.secret_store) + ' ' +\
12105            '>'
12106
12107    def to_dict(self):
12108        return {
12109            'meta': self.meta,
12110            'rate_limit': self.rate_limit,
12111            'secret_store': self.secret_store,
12112        }
12113
12114    @classmethod
12115    def from_dict(cls, d):
12116        return cls(
12117            meta=d.get('meta'),
12118            rate_limit=d.get('rate_limit'),
12119            secret_store=d.get('secret_store'),
12120        )
12121
12122
12123class Service:
12124    '''
12125     A Service is a service account that can connect to resources they are granted
12126     directly, or granted via roles. Services are typically automated jobs.
12127    '''
12128    __slots__ = [
12129        'id',
12130        'name',
12131        'suspended',
12132        'tags',
12133    ]
12134
12135    def __init__(
12136        self,
12137        id=None,
12138        name=None,
12139        suspended=None,
12140        tags=None,
12141    ):
12142        self.id = id if id is not None else ''
12143        '''
12144         Unique identifier of the Service.
12145        '''
12146        self.name = name if name is not None else ''
12147        '''
12148         Unique human-readable name of the Service.
12149        '''
12150        self.suspended = suspended if suspended is not None else False
12151        '''
12152         The Service's suspended state.
12153        '''
12154        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12155        '''
12156         Tags is a map of key, value pairs.
12157        '''
12158
12159    def __repr__(self):
12160        return '<sdm.Service ' + \
12161            'id: ' + repr(self.id) + ' ' +\
12162            'name: ' + repr(self.name) + ' ' +\
12163            'suspended: ' + repr(self.suspended) + ' ' +\
12164            'tags: ' + repr(self.tags) + ' ' +\
12165            '>'
12166
12167    def to_dict(self):
12168        return {
12169            'id': self.id,
12170            'name': self.name,
12171            'suspended': self.suspended,
12172            'tags': self.tags,
12173        }
12174
12175    @classmethod
12176    def from_dict(cls, d):
12177        return cls(
12178            id=d.get('id'),
12179            name=d.get('name'),
12180            suspended=d.get('suspended'),
12181            tags=d.get('tags'),
12182        )
12183
12184
12185class SingleStore:
12186    '''
12187
12188    '''
12189    __slots__ = [
12190        'bind_interface',
12191        'database',
12192        'egress_filter',
12193        'healthy',
12194        'hostname',
12195        'id',
12196        'name',
12197        'password',
12198        'port',
12199        'port_override',
12200        'secret_store_id',
12201        'tags',
12202        'username',
12203    ]
12204
12205    def __init__(
12206        self,
12207        bind_interface=None,
12208        database=None,
12209        egress_filter=None,
12210        healthy=None,
12211        hostname=None,
12212        id=None,
12213        name=None,
12214        password=None,
12215        port=None,
12216        port_override=None,
12217        secret_store_id=None,
12218        tags=None,
12219        username=None,
12220    ):
12221        self.bind_interface = bind_interface if bind_interface is not None else ''
12222        '''
12223         Bind interface
12224        '''
12225        self.database = database if database is not None else ''
12226        '''
12227
12228        '''
12229        self.egress_filter = egress_filter if egress_filter is not None else ''
12230        '''
12231         A filter applied to the routing logic to pin datasource to nodes.
12232        '''
12233        self.healthy = healthy if healthy is not None else False
12234        '''
12235         True if the datasource is reachable and the credentials are valid.
12236        '''
12237        self.hostname = hostname if hostname is not None else ''
12238        '''
12239
12240        '''
12241        self.id = id if id is not None else ''
12242        '''
12243         Unique identifier of the Resource.
12244        '''
12245        self.name = name if name is not None else ''
12246        '''
12247         Unique human-readable name of the Resource.
12248        '''
12249        self.password = password if password is not None else ''
12250        '''
12251
12252        '''
12253        self.port = port if port is not None else 0
12254        '''
12255
12256        '''
12257        self.port_override = port_override if port_override is not None else 0
12258        '''
12259
12260        '''
12261        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12262        '''
12263         ID of the secret store containing credentials for this resource, if any.
12264        '''
12265        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12266        '''
12267         Tags is a map of key, value pairs.
12268        '''
12269        self.username = username if username is not None else ''
12270        '''
12271
12272        '''
12273
12274    def __repr__(self):
12275        return '<sdm.SingleStore ' + \
12276            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12277            'database: ' + repr(self.database) + ' ' +\
12278            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12279            'healthy: ' + repr(self.healthy) + ' ' +\
12280            'hostname: ' + repr(self.hostname) + ' ' +\
12281            'id: ' + repr(self.id) + ' ' +\
12282            'name: ' + repr(self.name) + ' ' +\
12283            'password: ' + repr(self.password) + ' ' +\
12284            'port: ' + repr(self.port) + ' ' +\
12285            'port_override: ' + repr(self.port_override) + ' ' +\
12286            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12287            'tags: ' + repr(self.tags) + ' ' +\
12288            'username: ' + repr(self.username) + ' ' +\
12289            '>'
12290
12291    def to_dict(self):
12292        return {
12293            'bind_interface': self.bind_interface,
12294            'database': self.database,
12295            'egress_filter': self.egress_filter,
12296            'healthy': self.healthy,
12297            'hostname': self.hostname,
12298            'id': self.id,
12299            'name': self.name,
12300            'password': self.password,
12301            'port': self.port,
12302            'port_override': self.port_override,
12303            'secret_store_id': self.secret_store_id,
12304            'tags': self.tags,
12305            'username': self.username,
12306        }
12307
12308    @classmethod
12309    def from_dict(cls, d):
12310        return cls(
12311            bind_interface=d.get('bind_interface'),
12312            database=d.get('database'),
12313            egress_filter=d.get('egress_filter'),
12314            healthy=d.get('healthy'),
12315            hostname=d.get('hostname'),
12316            id=d.get('id'),
12317            name=d.get('name'),
12318            password=d.get('password'),
12319            port=d.get('port'),
12320            port_override=d.get('port_override'),
12321            secret_store_id=d.get('secret_store_id'),
12322            tags=d.get('tags'),
12323            username=d.get('username'),
12324        )
12325
12326
12327class Snowflake:
12328    '''
12329
12330    '''
12331    __slots__ = [
12332        'bind_interface',
12333        'database',
12334        'egress_filter',
12335        'healthy',
12336        'hostname',
12337        'id',
12338        'name',
12339        'password',
12340        'port_override',
12341        'schema',
12342        'secret_store_id',
12343        'tags',
12344        'username',
12345    ]
12346
12347    def __init__(
12348        self,
12349        bind_interface=None,
12350        database=None,
12351        egress_filter=None,
12352        healthy=None,
12353        hostname=None,
12354        id=None,
12355        name=None,
12356        password=None,
12357        port_override=None,
12358        schema=None,
12359        secret_store_id=None,
12360        tags=None,
12361        username=None,
12362    ):
12363        self.bind_interface = bind_interface if bind_interface is not None else ''
12364        '''
12365         Bind interface
12366        '''
12367        self.database = database if database is not None else ''
12368        '''
12369
12370        '''
12371        self.egress_filter = egress_filter if egress_filter is not None else ''
12372        '''
12373         A filter applied to the routing logic to pin datasource to nodes.
12374        '''
12375        self.healthy = healthy if healthy is not None else False
12376        '''
12377         True if the datasource is reachable and the credentials are valid.
12378        '''
12379        self.hostname = hostname if hostname is not None else ''
12380        '''
12381
12382        '''
12383        self.id = id if id is not None else ''
12384        '''
12385         Unique identifier of the Resource.
12386        '''
12387        self.name = name if name is not None else ''
12388        '''
12389         Unique human-readable name of the Resource.
12390        '''
12391        self.password = password if password is not None else ''
12392        '''
12393
12394        '''
12395        self.port_override = port_override if port_override is not None else 0
12396        '''
12397
12398        '''
12399        self.schema = schema if schema is not None else ''
12400        '''
12401
12402        '''
12403        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12404        '''
12405         ID of the secret store containing credentials for this resource, if any.
12406        '''
12407        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12408        '''
12409         Tags is a map of key, value pairs.
12410        '''
12411        self.username = username if username is not None else ''
12412        '''
12413
12414        '''
12415
12416    def __repr__(self):
12417        return '<sdm.Snowflake ' + \
12418            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12419            'database: ' + repr(self.database) + ' ' +\
12420            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12421            'healthy: ' + repr(self.healthy) + ' ' +\
12422            'hostname: ' + repr(self.hostname) + ' ' +\
12423            'id: ' + repr(self.id) + ' ' +\
12424            'name: ' + repr(self.name) + ' ' +\
12425            'password: ' + repr(self.password) + ' ' +\
12426            'port_override: ' + repr(self.port_override) + ' ' +\
12427            'schema: ' + repr(self.schema) + ' ' +\
12428            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12429            'tags: ' + repr(self.tags) + ' ' +\
12430            'username: ' + repr(self.username) + ' ' +\
12431            '>'
12432
12433    def to_dict(self):
12434        return {
12435            'bind_interface': self.bind_interface,
12436            'database': self.database,
12437            'egress_filter': self.egress_filter,
12438            'healthy': self.healthy,
12439            'hostname': self.hostname,
12440            'id': self.id,
12441            'name': self.name,
12442            'password': self.password,
12443            'port_override': self.port_override,
12444            'schema': self.schema,
12445            'secret_store_id': self.secret_store_id,
12446            'tags': self.tags,
12447            'username': self.username,
12448        }
12449
12450    @classmethod
12451    def from_dict(cls, d):
12452        return cls(
12453            bind_interface=d.get('bind_interface'),
12454            database=d.get('database'),
12455            egress_filter=d.get('egress_filter'),
12456            healthy=d.get('healthy'),
12457            hostname=d.get('hostname'),
12458            id=d.get('id'),
12459            name=d.get('name'),
12460            password=d.get('password'),
12461            port_override=d.get('port_override'),
12462            schema=d.get('schema'),
12463            secret_store_id=d.get('secret_store_id'),
12464            tags=d.get('tags'),
12465            username=d.get('username'),
12466        )
12467
12468
12469class Sybase:
12470    '''
12471
12472    '''
12473    __slots__ = [
12474        'bind_interface',
12475        'egress_filter',
12476        'healthy',
12477        'hostname',
12478        'id',
12479        'name',
12480        'password',
12481        'port',
12482        'port_override',
12483        'secret_store_id',
12484        'tags',
12485        'username',
12486    ]
12487
12488    def __init__(
12489        self,
12490        bind_interface=None,
12491        egress_filter=None,
12492        healthy=None,
12493        hostname=None,
12494        id=None,
12495        name=None,
12496        password=None,
12497        port=None,
12498        port_override=None,
12499        secret_store_id=None,
12500        tags=None,
12501        username=None,
12502    ):
12503        self.bind_interface = bind_interface if bind_interface is not None else ''
12504        '''
12505         Bind interface
12506        '''
12507        self.egress_filter = egress_filter if egress_filter is not None else ''
12508        '''
12509         A filter applied to the routing logic to pin datasource to nodes.
12510        '''
12511        self.healthy = healthy if healthy is not None else False
12512        '''
12513         True if the datasource is reachable and the credentials are valid.
12514        '''
12515        self.hostname = hostname if hostname is not None else ''
12516        '''
12517
12518        '''
12519        self.id = id if id is not None else ''
12520        '''
12521         Unique identifier of the Resource.
12522        '''
12523        self.name = name if name is not None else ''
12524        '''
12525         Unique human-readable name of the Resource.
12526        '''
12527        self.password = password if password is not None else ''
12528        '''
12529
12530        '''
12531        self.port = port if port is not None else 0
12532        '''
12533
12534        '''
12535        self.port_override = port_override if port_override is not None else 0
12536        '''
12537
12538        '''
12539        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12540        '''
12541         ID of the secret store containing credentials for this resource, if any.
12542        '''
12543        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12544        '''
12545         Tags is a map of key, value pairs.
12546        '''
12547        self.username = username if username is not None else ''
12548        '''
12549
12550        '''
12551
12552    def __repr__(self):
12553        return '<sdm.Sybase ' + \
12554            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12555            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12556            'healthy: ' + repr(self.healthy) + ' ' +\
12557            'hostname: ' + repr(self.hostname) + ' ' +\
12558            'id: ' + repr(self.id) + ' ' +\
12559            'name: ' + repr(self.name) + ' ' +\
12560            'password: ' + repr(self.password) + ' ' +\
12561            'port: ' + repr(self.port) + ' ' +\
12562            'port_override: ' + repr(self.port_override) + ' ' +\
12563            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12564            'tags: ' + repr(self.tags) + ' ' +\
12565            'username: ' + repr(self.username) + ' ' +\
12566            '>'
12567
12568    def to_dict(self):
12569        return {
12570            'bind_interface': self.bind_interface,
12571            'egress_filter': self.egress_filter,
12572            'healthy': self.healthy,
12573            'hostname': self.hostname,
12574            'id': self.id,
12575            'name': self.name,
12576            'password': self.password,
12577            'port': self.port,
12578            'port_override': self.port_override,
12579            'secret_store_id': self.secret_store_id,
12580            'tags': self.tags,
12581            'username': self.username,
12582        }
12583
12584    @classmethod
12585    def from_dict(cls, d):
12586        return cls(
12587            bind_interface=d.get('bind_interface'),
12588            egress_filter=d.get('egress_filter'),
12589            healthy=d.get('healthy'),
12590            hostname=d.get('hostname'),
12591            id=d.get('id'),
12592            name=d.get('name'),
12593            password=d.get('password'),
12594            port=d.get('port'),
12595            port_override=d.get('port_override'),
12596            secret_store_id=d.get('secret_store_id'),
12597            tags=d.get('tags'),
12598            username=d.get('username'),
12599        )
12600
12601
12602class SybaseIQ:
12603    '''
12604
12605    '''
12606    __slots__ = [
12607        'bind_interface',
12608        'egress_filter',
12609        'healthy',
12610        'hostname',
12611        'id',
12612        'name',
12613        'password',
12614        'port',
12615        'port_override',
12616        'secret_store_id',
12617        'tags',
12618        'username',
12619    ]
12620
12621    def __init__(
12622        self,
12623        bind_interface=None,
12624        egress_filter=None,
12625        healthy=None,
12626        hostname=None,
12627        id=None,
12628        name=None,
12629        password=None,
12630        port=None,
12631        port_override=None,
12632        secret_store_id=None,
12633        tags=None,
12634        username=None,
12635    ):
12636        self.bind_interface = bind_interface if bind_interface is not None else ''
12637        '''
12638         Bind interface
12639        '''
12640        self.egress_filter = egress_filter if egress_filter is not None else ''
12641        '''
12642         A filter applied to the routing logic to pin datasource to nodes.
12643        '''
12644        self.healthy = healthy if healthy is not None else False
12645        '''
12646         True if the datasource is reachable and the credentials are valid.
12647        '''
12648        self.hostname = hostname if hostname is not None else ''
12649        '''
12650
12651        '''
12652        self.id = id if id is not None else ''
12653        '''
12654         Unique identifier of the Resource.
12655        '''
12656        self.name = name if name is not None else ''
12657        '''
12658         Unique human-readable name of the Resource.
12659        '''
12660        self.password = password if password is not None else ''
12661        '''
12662
12663        '''
12664        self.port = port if port is not None else 0
12665        '''
12666
12667        '''
12668        self.port_override = port_override if port_override is not None else 0
12669        '''
12670
12671        '''
12672        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12673        '''
12674         ID of the secret store containing credentials for this resource, if any.
12675        '''
12676        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12677        '''
12678         Tags is a map of key, value pairs.
12679        '''
12680        self.username = username if username is not None else ''
12681        '''
12682
12683        '''
12684
12685    def __repr__(self):
12686        return '<sdm.SybaseIQ ' + \
12687            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12688            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12689            'healthy: ' + repr(self.healthy) + ' ' +\
12690            'hostname: ' + repr(self.hostname) + ' ' +\
12691            'id: ' + repr(self.id) + ' ' +\
12692            'name: ' + repr(self.name) + ' ' +\
12693            'password: ' + repr(self.password) + ' ' +\
12694            'port: ' + repr(self.port) + ' ' +\
12695            'port_override: ' + repr(self.port_override) + ' ' +\
12696            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12697            'tags: ' + repr(self.tags) + ' ' +\
12698            'username: ' + repr(self.username) + ' ' +\
12699            '>'
12700
12701    def to_dict(self):
12702        return {
12703            'bind_interface': self.bind_interface,
12704            'egress_filter': self.egress_filter,
12705            'healthy': self.healthy,
12706            'hostname': self.hostname,
12707            'id': self.id,
12708            'name': self.name,
12709            'password': self.password,
12710            'port': self.port,
12711            'port_override': self.port_override,
12712            'secret_store_id': self.secret_store_id,
12713            'tags': self.tags,
12714            'username': self.username,
12715        }
12716
12717    @classmethod
12718    def from_dict(cls, d):
12719        return cls(
12720            bind_interface=d.get('bind_interface'),
12721            egress_filter=d.get('egress_filter'),
12722            healthy=d.get('healthy'),
12723            hostname=d.get('hostname'),
12724            id=d.get('id'),
12725            name=d.get('name'),
12726            password=d.get('password'),
12727            port=d.get('port'),
12728            port_override=d.get('port_override'),
12729            secret_store_id=d.get('secret_store_id'),
12730            tags=d.get('tags'),
12731            username=d.get('username'),
12732        )
12733
12734
12735class Tag:
12736    '''
12737
12738    '''
12739    __slots__ = [
12740        'name',
12741        'value',
12742    ]
12743
12744    def __init__(
12745        self,
12746        name=None,
12747        value=None,
12748    ):
12749        self.name = name if name is not None else ''
12750        '''
12751
12752        '''
12753        self.value = value if value is not None else ''
12754        '''
12755
12756        '''
12757
12758    def __repr__(self):
12759        return '<sdm.Tag ' + \
12760            'name: ' + repr(self.name) + ' ' +\
12761            'value: ' + repr(self.value) + ' ' +\
12762            '>'
12763
12764    def to_dict(self):
12765        return {
12766            'name': self.name,
12767            'value': self.value,
12768        }
12769
12770    @classmethod
12771    def from_dict(cls, d):
12772        return cls(
12773            name=d.get('name'),
12774            value=d.get('value'),
12775        )
12776
12777
12778class Teradata:
12779    '''
12780
12781    '''
12782    __slots__ = [
12783        'bind_interface',
12784        'egress_filter',
12785        'healthy',
12786        'hostname',
12787        'id',
12788        'name',
12789        'password',
12790        'port',
12791        'port_override',
12792        'secret_store_id',
12793        'tags',
12794        'username',
12795    ]
12796
12797    def __init__(
12798        self,
12799        bind_interface=None,
12800        egress_filter=None,
12801        healthy=None,
12802        hostname=None,
12803        id=None,
12804        name=None,
12805        password=None,
12806        port=None,
12807        port_override=None,
12808        secret_store_id=None,
12809        tags=None,
12810        username=None,
12811    ):
12812        self.bind_interface = bind_interface if bind_interface is not None else ''
12813        '''
12814         Bind interface
12815        '''
12816        self.egress_filter = egress_filter if egress_filter is not None else ''
12817        '''
12818         A filter applied to the routing logic to pin datasource to nodes.
12819        '''
12820        self.healthy = healthy if healthy is not None else False
12821        '''
12822         True if the datasource is reachable and the credentials are valid.
12823        '''
12824        self.hostname = hostname if hostname is not None else ''
12825        '''
12826
12827        '''
12828        self.id = id if id is not None else ''
12829        '''
12830         Unique identifier of the Resource.
12831        '''
12832        self.name = name if name is not None else ''
12833        '''
12834         Unique human-readable name of the Resource.
12835        '''
12836        self.password = password if password is not None else ''
12837        '''
12838
12839        '''
12840        self.port = port if port is not None else 0
12841        '''
12842
12843        '''
12844        self.port_override = port_override if port_override is not None else 0
12845        '''
12846
12847        '''
12848        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12849        '''
12850         ID of the secret store containing credentials for this resource, if any.
12851        '''
12852        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12853        '''
12854         Tags is a map of key, value pairs.
12855        '''
12856        self.username = username if username is not None else ''
12857        '''
12858
12859        '''
12860
12861    def __repr__(self):
12862        return '<sdm.Teradata ' + \
12863            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12864            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12865            'healthy: ' + repr(self.healthy) + ' ' +\
12866            'hostname: ' + repr(self.hostname) + ' ' +\
12867            'id: ' + repr(self.id) + ' ' +\
12868            'name: ' + repr(self.name) + ' ' +\
12869            'password: ' + repr(self.password) + ' ' +\
12870            'port: ' + repr(self.port) + ' ' +\
12871            'port_override: ' + repr(self.port_override) + ' ' +\
12872            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12873            'tags: ' + repr(self.tags) + ' ' +\
12874            'username: ' + repr(self.username) + ' ' +\
12875            '>'
12876
12877    def to_dict(self):
12878        return {
12879            'bind_interface': self.bind_interface,
12880            'egress_filter': self.egress_filter,
12881            'healthy': self.healthy,
12882            'hostname': self.hostname,
12883            'id': self.id,
12884            'name': self.name,
12885            'password': self.password,
12886            'port': self.port,
12887            'port_override': self.port_override,
12888            'secret_store_id': self.secret_store_id,
12889            'tags': self.tags,
12890            'username': self.username,
12891        }
12892
12893    @classmethod
12894    def from_dict(cls, d):
12895        return cls(
12896            bind_interface=d.get('bind_interface'),
12897            egress_filter=d.get('egress_filter'),
12898            healthy=d.get('healthy'),
12899            hostname=d.get('hostname'),
12900            id=d.get('id'),
12901            name=d.get('name'),
12902            password=d.get('password'),
12903            port=d.get('port'),
12904            port_override=d.get('port_override'),
12905            secret_store_id=d.get('secret_store_id'),
12906            tags=d.get('tags'),
12907            username=d.get('username'),
12908        )
12909
12910
12911class UpdateResponseMetadata:
12912    '''
12913     UpdateResponseMetadata is reserved for future use.
12914    '''
12915    __slots__ = []
12916
12917    def __init__(self, ):
12918        pass
12919
12920    def __repr__(self):
12921        return '<sdm.UpdateResponseMetadata ' + \
12922            '>'
12923
12924    def to_dict(self):
12925        return {}
12926
12927    @classmethod
12928    def from_dict(cls, d):
12929        return cls()
12930
12931
12932class User:
12933    '''
12934     A User can connect to resources they are granted directly, or granted
12935     via roles.
12936    '''
12937    __slots__ = [
12938        'email',
12939        'first_name',
12940        'id',
12941        'last_name',
12942        'suspended',
12943        'tags',
12944    ]
12945
12946    def __init__(
12947        self,
12948        email=None,
12949        first_name=None,
12950        id=None,
12951        last_name=None,
12952        suspended=None,
12953        tags=None,
12954    ):
12955        self.email = email if email is not None else ''
12956        '''
12957         The User's email address. Must be unique.
12958        '''
12959        self.first_name = first_name if first_name is not None else ''
12960        '''
12961         The User's first name.
12962        '''
12963        self.id = id if id is not None else ''
12964        '''
12965         Unique identifier of the User.
12966        '''
12967        self.last_name = last_name if last_name is not None else ''
12968        '''
12969         The User's last name.
12970        '''
12971        self.suspended = suspended if suspended is not None else False
12972        '''
12973         The User's suspended state.
12974        '''
12975        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12976        '''
12977         Tags is a map of key, value pairs.
12978        '''
12979
12980    def __repr__(self):
12981        return '<sdm.User ' + \
12982            'email: ' + repr(self.email) + ' ' +\
12983            'first_name: ' + repr(self.first_name) + ' ' +\
12984            'id: ' + repr(self.id) + ' ' +\
12985            'last_name: ' + repr(self.last_name) + ' ' +\
12986            'suspended: ' + repr(self.suspended) + ' ' +\
12987            'tags: ' + repr(self.tags) + ' ' +\
12988            '>'
12989
12990    def to_dict(self):
12991        return {
12992            'email': self.email,
12993            'first_name': self.first_name,
12994            'id': self.id,
12995            'last_name': self.last_name,
12996            'suspended': self.suspended,
12997            'tags': self.tags,
12998        }
12999
13000    @classmethod
13001    def from_dict(cls, d):
13002        return cls(
13003            email=d.get('email'),
13004            first_name=d.get('first_name'),
13005            id=d.get('id'),
13006            last_name=d.get('last_name'),
13007            suspended=d.get('suspended'),
13008            tags=d.get('tags'),
13009        )
13010
13011
13012class VaultAppRoleStore:
13013    '''
13014
13015    '''
13016    __slots__ = [
13017        'id',
13018        'name',
13019        'namespace',
13020        'server_address',
13021        'tags',
13022    ]
13023
13024    def __init__(
13025        self,
13026        id=None,
13027        name=None,
13028        namespace=None,
13029        server_address=None,
13030        tags=None,
13031    ):
13032        self.id = id if id is not None else ''
13033        '''
13034         Unique identifier of the SecretStore.
13035        '''
13036        self.name = name if name is not None else ''
13037        '''
13038         Unique human-readable name of the SecretStore.
13039        '''
13040        self.namespace = namespace if namespace is not None else ''
13041        '''
13042
13043        '''
13044        self.server_address = server_address if server_address is not None else ''
13045        '''
13046
13047        '''
13048        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13049        '''
13050         Tags is a map of key, value pairs.
13051        '''
13052
13053    def __repr__(self):
13054        return '<sdm.VaultAppRoleStore ' + \
13055            'id: ' + repr(self.id) + ' ' +\
13056            'name: ' + repr(self.name) + ' ' +\
13057            'namespace: ' + repr(self.namespace) + ' ' +\
13058            'server_address: ' + repr(self.server_address) + ' ' +\
13059            'tags: ' + repr(self.tags) + ' ' +\
13060            '>'
13061
13062    def to_dict(self):
13063        return {
13064            'id': self.id,
13065            'name': self.name,
13066            'namespace': self.namespace,
13067            'server_address': self.server_address,
13068            'tags': self.tags,
13069        }
13070
13071    @classmethod
13072    def from_dict(cls, d):
13073        return cls(
13074            id=d.get('id'),
13075            name=d.get('name'),
13076            namespace=d.get('namespace'),
13077            server_address=d.get('server_address'),
13078            tags=d.get('tags'),
13079        )
13080
13081
13082class VaultTLSStore:
13083    '''
13084
13085    '''
13086    __slots__ = [
13087        'ca_cert_path',
13088        'client_cert_path',
13089        'client_key_path',
13090        'id',
13091        'name',
13092        'namespace',
13093        'server_address',
13094        'tags',
13095    ]
13096
13097    def __init__(
13098        self,
13099        ca_cert_path=None,
13100        client_cert_path=None,
13101        client_key_path=None,
13102        id=None,
13103        name=None,
13104        namespace=None,
13105        server_address=None,
13106        tags=None,
13107    ):
13108        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
13109        '''
13110
13111        '''
13112        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
13113        '''
13114
13115        '''
13116        self.client_key_path = client_key_path if client_key_path is not None else ''
13117        '''
13118
13119        '''
13120        self.id = id if id is not None else ''
13121        '''
13122         Unique identifier of the SecretStore.
13123        '''
13124        self.name = name if name is not None else ''
13125        '''
13126         Unique human-readable name of the SecretStore.
13127        '''
13128        self.namespace = namespace if namespace is not None else ''
13129        '''
13130
13131        '''
13132        self.server_address = server_address if server_address is not None else ''
13133        '''
13134
13135        '''
13136        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13137        '''
13138         Tags is a map of key, value pairs.
13139        '''
13140
13141    def __repr__(self):
13142        return '<sdm.VaultTLSStore ' + \
13143            'ca_cert_path: ' + repr(self.ca_cert_path) + ' ' +\
13144            'client_cert_path: ' + repr(self.client_cert_path) + ' ' +\
13145            'client_key_path: ' + repr(self.client_key_path) + ' ' +\
13146            'id: ' + repr(self.id) + ' ' +\
13147            'name: ' + repr(self.name) + ' ' +\
13148            'namespace: ' + repr(self.namespace) + ' ' +\
13149            'server_address: ' + repr(self.server_address) + ' ' +\
13150            'tags: ' + repr(self.tags) + ' ' +\
13151            '>'
13152
13153    def to_dict(self):
13154        return {
13155            'ca_cert_path': self.ca_cert_path,
13156            'client_cert_path': self.client_cert_path,
13157            'client_key_path': self.client_key_path,
13158            'id': self.id,
13159            'name': self.name,
13160            'namespace': self.namespace,
13161            'server_address': self.server_address,
13162            'tags': self.tags,
13163        }
13164
13165    @classmethod
13166    def from_dict(cls, d):
13167        return cls(
13168            ca_cert_path=d.get('ca_cert_path'),
13169            client_cert_path=d.get('client_cert_path'),
13170            client_key_path=d.get('client_key_path'),
13171            id=d.get('id'),
13172            name=d.get('name'),
13173            namespace=d.get('namespace'),
13174            server_address=d.get('server_address'),
13175            tags=d.get('tags'),
13176        )
13177
13178
13179class VaultTokenStore:
13180    '''
13181
13182    '''
13183    __slots__ = [
13184        'id',
13185        'name',
13186        'namespace',
13187        'server_address',
13188        'tags',
13189    ]
13190
13191    def __init__(
13192        self,
13193        id=None,
13194        name=None,
13195        namespace=None,
13196        server_address=None,
13197        tags=None,
13198    ):
13199        self.id = id if id is not None else ''
13200        '''
13201         Unique identifier of the SecretStore.
13202        '''
13203        self.name = name if name is not None else ''
13204        '''
13205         Unique human-readable name of the SecretStore.
13206        '''
13207        self.namespace = namespace if namespace is not None else ''
13208        '''
13209
13210        '''
13211        self.server_address = server_address if server_address is not None else ''
13212        '''
13213
13214        '''
13215        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13216        '''
13217         Tags is a map of key, value pairs.
13218        '''
13219
13220    def __repr__(self):
13221        return '<sdm.VaultTokenStore ' + \
13222            'id: ' + repr(self.id) + ' ' +\
13223            'name: ' + repr(self.name) + ' ' +\
13224            'namespace: ' + repr(self.namespace) + ' ' +\
13225            'server_address: ' + repr(self.server_address) + ' ' +\
13226            'tags: ' + repr(self.tags) + ' ' +\
13227            '>'
13228
13229    def to_dict(self):
13230        return {
13231            'id': self.id,
13232            'name': self.name,
13233            'namespace': self.namespace,
13234            'server_address': self.server_address,
13235            'tags': self.tags,
13236        }
13237
13238    @classmethod
13239    def from_dict(cls, d):
13240        return cls(
13241            id=d.get('id'),
13242            name=d.get('name'),
13243            namespace=d.get('namespace'),
13244            server_address=d.get('server_address'),
13245            tags=d.get('tags'),
13246        )
13247
13248
13249def _porcelain_zero_value_tags():
13250    return {}
13251
13252
13253def _porcelain_zero_value_access_rules():
13254    return []